source/atmitest/atmiunit1.c

0001 /**
0002  * @brief Main ATMI unit test dispatcher.
0003  *
0004  * @file atmiunit1.c
0005  */
0006 /* -----------------------------------------------------------------------------
0007  * Enduro/X Middleware Platform for Distributed Transaction Processing
0008  * Copyright (C) 2009-2016, ATR Baltic, Ltd. All Rights Reserved.
0009  * Copyright (C) 2017-2023, Mavimax, Ltd. All Rights Reserved.
0010  * This software is released under one of the following licenses:
0011  * AGPL (with Java and Go exceptions) or Mavimax's license for commercial use.
0012  * See LICENSE file for full text.
0013  * -----------------------------------------------------------------------------
0014  * AGPL license:
0015  *
0016  * This program is free software; you can redistribute it and/or modify it under
0017  * the terms of the GNU Affero General Public License, version 3 as published
0018  * by the Free Software Foundation;
0019  *
0020  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
0021  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0022  * PARTICULAR PURPOSE. See the GNU Affero General Public License, version 3
0023  * for more details.
0024  *
0025  * You should have received a copy of the GNU Affero General Public License along
0026  * with this program; if not, write to the Free Software Foundation, Inc.,
0027  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0028  *
0029  * -----------------------------------------------------------------------------
0030  * A commercial use license is available from Mavimax, Ltd
0031  * contact@mavimax.com
0032  * -----------------------------------------------------------------------------
0033  */
0034 #include <ndrx_config.h>
0035 #include <stdio.h>
0036 #include <stdlib.h>
0037 #include <cgreen/cgreen.h>
0038 #include "atmiuni1.h"
0039
0040 #include <ndrstandard.h>
0041
0042 /*---------------------------Externs------------------------------------*/
0043 /*---------------------------Macros-------------------------------------*/
0044 /*---------------------------Enums--------------------------------------*/
0045 /*---------------------------Typedefs-----------------------------------*/
0046 /*---------------------------Globals------------------------------------*/
0047 /*---------------------------Statics------------------------------------*/
0048 /*---------------------------Prototypes---------------------------------*/
0049
0050 int system_dbg(char *cmd)
0051 {
0052     int ret;
0053     fprintf(stderr, "************ RUNNING TEST: [%s] *********************\n", cmd);
0054     ret=system(cmd);
0055     fprintf(stderr, "************ FINISHED TEST: [%s] with %d ************\n", cmd, ret);
0056     return ret;
0057 }
0058
0059 Ensure(test000_system)
0060 {
0061     int ret;
0062     ret=system_dbg("test000_system/run.sh");
0063     assert_equal(ret, EXSUCCEED);
0064 }
0065
0066 Ensure(test000_system_atmiunit0)
0067 {
0068     int ret;
0069     ret=system_dbg("test000_system/run-unit.sh");
0070     assert_equal(ret, EXSUCCEED);
0071 }
0072
0073 Ensure(test001_basiccall)
0074 {
0075     int ret;
0076     ret=system_dbg("test001_basiccall/run.sh");
0077     assert_equal(ret, EXSUCCEED);
0078 }
0079
0080 Ensure(test002_basicforward)
0081 {
0082     int ret;
0083     ret=system_dbg("test002_basicforward/run.sh");
0084     assert_equal(ret, EXSUCCEED);
0085 }
0086
0087 Ensure(test003_basicconvers)
0088 {
0089     int ret;
0090     ret=system_dbg("test003_basicconvers/run.sh");
0091     assert_equal(ret, EXSUCCEED);
0092 }
0093
0094 Ensure(test004_basicevent)
0095 {
0096     int ret;
0097     ret=system_dbg("test004_basicevent/run.sh");
0098     assert_equal(ret, EXSUCCEED);
0099
0100 }
0101
0102 Ensure(test005_convconfload)
0103 {
0104     int ret;
0105     ret=system_dbg("test005_convconfload/run.sh");
0106     assert_equal(ret, EXSUCCEED);
0107 }
0108
0109 Ensure(test006_ulog)
0110 {
0111     int ret;
0112     ret=system_dbg("test006_ulog/run.sh");
0113     assert_equal(ret, EXSUCCEED);
0114 }
0115
0116 Ensure(test007_advertise)
0117 {
0118     int ret;
0119     ret=system_dbg("test007_advertise/run.sh");
0120     assert_equal(ret, EXSUCCEED);
0121 }
0122
0123 Ensure(test008_extensions)
0124 {
0125     int ret;
0126     ret=system_dbg("test008_extensions/run.sh");
0127     assert_equal(ret, EXSUCCEED);
0128 }
0129
0130 Ensure(test009_srvdie)
0131 {
0132     int ret;
0133     ret=system_dbg("test009_srvdie/run.sh");
0134     assert_equal(ret, EXSUCCEED);
0135 }
0136
0137 Ensure(test010_strtracecond)
0138 {
0139     int ret;
0140     ret=system_dbg("test010_strtracecond/run.sh");
0141     assert_equal(ret, EXSUCCEED);
0142 }
0143
0144 Ensure(test011_tout)
0145 {
0146     int ret;
0147     ret=system_dbg("test011_tout/run.sh");
0148     assert_equal(ret, EXSUCCEED);
0149 }
0150
0151 Ensure(test012_admqfull)
0152 {
0153     int ret;
0154     ret=system_dbg("test012_admqfull/run.sh");
0155     assert_equal(ret, EXSUCCEED);
0156 }
0157
0158 Ensure(test001_basiccall_dom)
0159 {
0160     int ret;
0161     ret=system_dbg("test001_basiccall/run-dom.sh");
0162     assert_equal(ret, EXSUCCEED);
0163 }
0164
0165 Ensure(test002_basicforward_dom)
0166 {
0167     int ret;
0168     ret=system_dbg("test002_basicforward/run-dom.sh");
0169     assert_equal(ret, EXSUCCEED);
0170 }
0171
0172 Ensure(test003_basicconvers_dom)
0173 {
0174     int ret;
0175     ret=system_dbg("test003_basicconvers/run-dom.sh");
0176     assert_equal(ret, EXSUCCEED);
0177 }
0178
0179 Ensure(test004_basicevent_dom)
0180 {
0181     int ret;
0182     ret=system_dbg("test004_basicevent/run-dom.sh");
0183     assert_equal(ret, EXSUCCEED);
0184
0185 }
0186
0187 Ensure(test013_procnorsp)
0188 {
0189     int ret;
0190     ret=system_dbg("test013_procnorsp/run.sh");
0191     assert_equal(ret, EXSUCCEED);
0192 }
0193
0194 Ensure(test015_threads)
0195 {
0196     int ret;
0197     ret=system_dbg("test015_threads/run.sh");
0198     assert_equal(ret, EXSUCCEED);
0199 }
0200
0201 Ensure(test017_srvthread)
0202 {
0203     int ret;
0204     ret=system_dbg("test017_srvthread/run.sh");
0205     assert_equal(ret, EXSUCCEED);
0206 }
0207
0208 Ensure(test018_tpacalltout)
0209 {
0210     int ret;
0211     ret=system_dbg("test018_tpacalltout/run.sh");
0212     assert_equal(ret, EXSUCCEED);
0213 }
0214
0215 Ensure(test021_xafull)
0216 {
0217     int ret;
0218     ret=system_dbg("test021_xafull/run.sh");
0219     assert_equal(ret, EXSUCCEED);
0220 }
0221
0222 Ensure(test022_typedstring)
0223 {
0224     int ret;
0225     ret=system_dbg("test022_typedstring/run.sh");
0226     assert_equal(ret, EXSUCCEED);
0227 }
0228
0229 Ensure(test023_typedcarray)
0230 {
0231     int ret;
0232     ret=system_dbg("test023_typedcarray/run.sh");
0233     assert_equal(ret, EXSUCCEED);
0234 }
0235
0236 Ensure(test024_json)
0237 {
0238     int ret;
0239     ret=system_dbg("test024_json/run.sh");
0240     assert_equal(ret, EXSUCCEED);
0241 }
0242
0243 Ensure(test025_cpmsrv)
0244 {
0245     int ret;
0246     ret=system_dbg("test025_cpmsrv/run.sh");
0247     assert_equal(ret, EXSUCCEED);
0248 }
0249
0250 Ensure(test026_typedjson)
0251 {
0252     int ret;
0253     ret=system_dbg("test026_typedjson/run.sh");
0254     assert_equal(ret, EXSUCCEED);
0255 }
0256
0257 Ensure(test027_pscript)
0258 {
0259     int ret;
0260     ret=system_dbg("test027_pscript/run.sh");
0261     assert_equal(ret, EXSUCCEED);
0262 }
0263
0264 Ensure(test028_tmq)
0265 {
0266     int ret;
0267     ret=system_dbg("test028_tmq/run.sh");
0268     assert_equal(ret, EXSUCCEED);
0269 }
0270
0271 Ensure(test029_inicfg)
0272 {
0273     int ret;
0274     ret=system_dbg("test029_inicfg/run.sh");
0275     assert_equal(ret, EXSUCCEED);
0276 }
0277
0278 Ensure(test030_cconfsrv)
0279 {
0280     int ret;
0281     ret=system_dbg("test030_cconfsrv/run.sh");
0282     assert_equal(ret, EXSUCCEED);
0283 }
0284
0285 Ensure(test031_logging)
0286 {
0287     int ret;
0288     ret=system_dbg("test031_logging/run.sh");
0289     assert_equal(ret, EXSUCCEED);
0290 }
0291
0292 Ensure(test032_oapi)
0293 {
0294     int ret;
0295     ret=system_dbg("test032_oapi/run.sh");
0296     assert_equal(ret, EXSUCCEED);
0297 }
0298
0299 Ensure(test033_provision)
0300 {
0301     int ret;
0302     ret=system_dbg("test033_provision/run.sh");
0303     assert_equal(ret, EXSUCCEED);
0304 }
0305
0306 Ensure(test034_shmreuse)
0307 {
0308     int ret;
0309     ret=system_dbg("test034_shmreuse/run.sh");
0310     assert_equal(ret, EXSUCCEED);
0311 }
0312
0313 Ensure(test035_hkeep)
0314 {
0315     int ret;
0316     ret=system_dbg("test035_hkeep/run.sh");
0317     assert_equal(ret, EXSUCCEED);
0318 }
0319
0320 Ensure(test036_tprecover)
0321 {
0322     int ret;
0323     ret=system_dbg("test036_tprecover/run.sh");
0324     assert_equal(ret, EXSUCCEED);
0325 }
0326
0327 Ensure(test037_down)
0328 {
0329     int ret;
0330     ret=system_dbg("test037_down/run.sh");
0331     assert_equal(ret, EXSUCCEED);
0332 }
0333
0334 Ensure(test038_tpnotify)
0335 {
0336     int ret;
0337     ret=system_dbg("test038_tpnotify/run.sh");
0338     assert_equal(ret, EXSUCCEED);
0339 }
0340
0341 Ensure(test039_tpbroadcast)
0342 {
0343     int ret;
0344     ret=system_dbg("test039_tpbroadcast/run.sh");
0345     assert_equal(ret, EXSUCCEED);
0346 }
0347
0348 Ensure(test040_typedview)
0349 {
0350     int ret;
0351     ret=system_dbg("test040_typedview/run.sh");
0352     assert_equal(ret, EXSUCCEED);
0353 }
0354
0355 Ensure(test040_typedview_dom)
0356 {
0357     int ret;
0358     ret=system_dbg("test040_typedview/run-dom.sh");
0359     assert_equal(ret, EXSUCCEED);
0360 }
0361
0362 Ensure(test041_bigmsg)
0363 {
0364     int ret;
0365     ret=system_dbg("test041_bigmsg/run.sh");
0366     assert_equal(ret, EXSUCCEED);
0367 }
0368 Ensure(test042_bignet)
0369 {
0370     int ret;
0371     ret=system_dbg("test042_bignet/run.sh");
0372     assert_equal(ret, EXSUCCEED);
0373 }
0374
0375 Ensure(test043_encrypt)
0376 {
0377     int ret;
0378     ret=system_dbg("test043_encrypt/run.sh");
0379     assert_equal(ret, EXSUCCEED);
0380 }
0381
0382 Ensure(test044_ping)
0383 {
0384     int ret;
0385     ret=system_dbg("test044_ping/run.sh");
0386     assert_equal(ret, EXSUCCEED);
0387 }
0388
0389 Ensure(test045_tpcallnoblock)
0390 {
0391     int ret;
0392     ret=system_dbg("test045_tpcallnoblock/run.sh");
0393     assert_equal(ret, EXSUCCEED);
0394 }
0395
0396 Ensure(test046_twopasscfg)
0397 {
0398     int ret;
0399     ret=system_dbg("test046_twopasscfg/run.sh");
0400     assert_equal(ret, EXSUCCEED);
0401 }
0402
0403 Ensure(test047_oradb)
0404 {
0405     int ret;
0406     ret=system_dbg("test047_oradb/run.sh");
0407     assert_equal(ret, EXSUCCEED);
0408 }
0409
0410 Ensure(test048_cache)
0411 {
0412     int ret;
0413     ret=system_dbg("test048_cache/run.sh");
0414     assert_equal(ret, EXSUCCEED);
0415 }
0416
0417 Ensure(test049_masksvc)
0418 {
0419     int ret;
0420     ret=system_dbg("test049_masksvc/run.sh");
0421     assert_equal(ret, EXSUCCEED);
0422 }
0423
0424 Ensure(test050_ubfdb)
0425 {
0426     int ret;
0427     ret=system_dbg("test050_ubfdb/run.sh");
0428     assert_equal(ret, EXSUCCEED);
0429 }
0430
0431 Ensure(test051_settout)
0432 {
0433     int ret;
0434     ret=system_dbg("test051_settout/run.sh");
0435     assert_equal(ret, EXSUCCEED);
0436 }
0437
0438 Ensure(test052_minstart)
0439 {
0440     int ret;
0441     ret=system_dbg("test052_minstart/run.sh");
0442     assert_equal(ret, EXSUCCEED);
0443 }
0444
0445 Ensure(test053_logoff)
0446 {
0447     int ret;
0448     ret=system_dbg("test053_logoff/run.sh");
0449     assert_equal(ret, EXSUCCEED);
0450 }
0451
0452 Ensure(test054_svwrap)
0453 {
0454     int ret;
0455     ret=system_dbg("test054_svwrap/run.sh");
0456     assert_equal(ret, EXSUCCEED);
0457 }
0458
0459 Ensure(test055_envs)
0460 {
0461     int ret;
0462     ret=system_dbg("test055_envs/run.sh");
0463     assert_equal(ret, EXSUCCEED);
0464 }
0465
0466 Ensure(test056_tpimpexp)
0467 {
0468     int ret;
0469     ret=system_dbg("test056_tpimpexp/run.sh");
0470     assert_equal(ret, EXSUCCEED);
0471 }
0472
0473
0474 Ensure(test057_invlcmd)
0475 {
0476     int ret;
0477     ret=system_dbg("test057_invlcmd/run.sh");
0478     assert_equal(ret, EXSUCCEED);
0479 }
0480
0481 Ensure(test058_systemv)
0482 {
0483     int ret;
0484     ret=system_dbg("test058_systemv/run.sh");
0485     assert_equal(ret, EXSUCCEED);
0486 }
0487
0488 Ensure(test059_pq)
0489 {
0490     int ret;
0491     ret=system_dbg("test059_pq/run.sh");
0492     assert_equal(ret, EXSUCCEED);
0493 }
0494
0495 Ensure(test060_ndxdfork)
0496 {
0497     int ret;
0498     ret=system_dbg("test060_ndxdfork/run.sh");
0499     assert_equal(ret, EXSUCCEED);
0500 }
0501
0502 Ensure(test061_ndxddup)
0503 {
0504     int ret;
0505     ret=system_dbg("test061_ndxddup/run.sh");
0506     assert_equal(ret, EXSUCCEED);
0507 }
0508
0509 Ensure(test062_memlimits)
0510 {
0511     int ret;
0512     ret=system_dbg("test062_memlimits/run.sh");
0513     assert_equal(ret, EXSUCCEED);
0514 }
0515
0516 Ensure(test063_cpmrange)
0517 {
0518     int ret;
0519     ret=system_dbg("test063_cpmrange/run.sh");
0520     assert_equal(ret, EXSUCCEED);
0521 }
0522
0523 Ensure(test064_bufswitch)
0524 {
0525     int ret;
0526     ret=system_dbg("test064_bufswitch/run.sh");
0527     assert_equal(ret, EXSUCCEED);
0528 }
0529
0530 Ensure(test065_tpcancel)
0531 {
0532     int ret;
0533     ret=system_dbg("test065_tpcancel/run.sh");
0534     assert_equal(ret, EXSUCCEED);
0535 }
0536
0537 Ensure(test066_tmstartserver)
0538 {
0539     int ret;
0540     ret=system_dbg("test066_tmstartserver/run.sh");
0541     assert_equal(ret, EXSUCCEED);
0542 }
0543
0544 Ensure(test067_postgres)
0545 {
0546     int ret;
0547     ret=system_dbg("test067_postgres/run.sh");
0548     assert_equal(ret, EXSUCCEED);
0549 }
0550
0551 Ensure(test068_tpadm)
0552 {
0553     int ret;
0554     ret=system_dbg("test068_tpadm/run.sh");
0555     assert_equal(ret, EXSUCCEED);
0556 }
0557
0558 Ensure(test069_wnormal)
0559 {
0560     int ret;
0561     ret=system_dbg("test069_wnormal/run.sh");
0562     assert_equal(ret, EXSUCCEED);
0563 }
0564
0565 Ensure(test070_ubfhook)
0566 {
0567     int ret;
0568     ret=system_dbg("test070_ubfhook/run.sh");
0569     assert_equal(ret, EXSUCCEED);
0570 }
0571
0572 Ensure(test071_buildtools)
0573 {
0574     int ret;
0575     ret=system_dbg("test071_buildtools/run.sh");
0576     assert_equal(ret, EXSUCCEED);
0577 }
0578
0579 Ensure(test072_qos)
0580 {
0581     int ret;
0582     ret=system_dbg("test072_qos/run.sh");
0583     assert_equal(ret, EXSUCCEED);
0584 }
0585
0586 Ensure(test073_netact)
0587 {
0588     int ret;
0589     ret=system_dbg("test073_netact/run.sh");
0590     assert_equal(ret, EXSUCCEED);
0591 }
0592
0593 Ensure(test074_sanitulog)
0594 {
0595     int ret;
0596     ret=system_dbg("test074_sanitulog/run.sh");
0597     assert_equal(ret, EXSUCCEED);
0598 }
0599
0600 Ensure(test075_dispthread)
0601 {
0602     int ret;
0603     ret=system_dbg("test075_dispthread/run.sh");
0604     assert_equal(ret, EXSUCCEED);
0605 }
0606
0607 Ensure(test076_dispthreadxa)
0608 {
0609     int ret;
0610     ret=system_dbg("test076_dispthreadxa/run.sh");
0611     assert_equal(ret, EXSUCCEED);
0612 }
0613
0614 Ensure(test077_diedslowstrt)
0615 {
0616     int ret;
0617     ret=system_dbg("test077_diedslowstrt/run.sh");
0618     assert_equal(ret, EXSUCCEED);
0619 }
0620
0621 Ensure(test078_tpacallmix)
0622 {
0623     int ret;
0624     ret=system_dbg("test078_tpacallmix/run.sh");
0625     assert_equal(ret, EXSUCCEED);
0626 }
0627
0628 Ensure(test079_cliquote)
0629 {
0630     int ret;
0631     ret=system_dbg("test079_cliquote/run.sh");
0632     assert_equal(ret, EXSUCCEED);
0633 }
0634
0635 Ensure(test080_tpexit)
0636 {
0637     int ret;
0638     ret=system_dbg("test080_tpexit/run.sh");
0639     assert_equal(ret, EXSUCCEED);
0640 }
0641
0642 Ensure(test081_lcf)
0643 {
0644     int ret;
0645     ret=system_dbg("test081_lcf/run.sh");
0646     assert_equal(ret, EXSUCCEED);
0647 }
0648
0649 Ensure(test082_autotran)
0650 {
0651     int ret;
0652     ret=system_dbg("test082_autotran/run.sh");
0653     assert_equal(ret, EXSUCCEED);
0654 }
0655
0656 Ensure(test083_ddrsyntax)
0657 {
0658     int ret;
0659     ret=system_dbg("test083_ddrsyntax/run.sh");
0660     assert_equal(ret, EXSUCCEED);
0661 }
0662
0663 Ensure(test084_ddr)
0664 {
0665     int ret;
0666     ret=system_dbg("test084_ddr/run.sh");
0667     assert_equal(ret, EXSUCCEED);
0668 }
0669
0670 Ensure(test085_prio)
0671 {
0672     int ret;
0673     ret=system_dbg("test085_prio/run.sh");
0674     assert_equal(ret, EXSUCCEED);
0675 }
0676
0677 Ensure(test086_tmqlimit)
0678 {
0679     int ret;
0680     ret=system_dbg("test086_tmqlimit/run.sh");
0681     assert_equal(ret, EXSUCCEED);
0682 }
0683
0684 /* first test shall fail all, as logs are overwritten */
0685 Ensure(test087_tmsrv)
0686 {
0687     int ret;
0688     if  (   (EXSUCCEED!=(ret=system_dbg("test087_tmsrv/run.sh")))
0689         ||  (EXSUCCEED!=(ret=system_dbg("test087_tmsrv/run-recon.sh")))
0690         ||  (EXSUCCEED!=(ret=system_dbg("test087_tmsrv/run-xa_end.sh")))
0691         )
0692     {
0693         assert_equal(ret, EXSUCCEED);
0694     }
0695 }
0696
0697 Ensure(test087_tmsrv_recon)
0698 {
0699     int ret;
0700     ret=system_dbg("test087_tmsrv/run-recon.sh");
0701     assert_equal(ret, EXSUCCEED);
0702 }
0703
0704 Ensure(test088_addlog)
0705 {
0706     int ret;
0707     ret=system_dbg("test088_addlog/run.sh");
0708     assert_equal(ret, EXSUCCEED);
0709 }
0710
0711 Ensure(test089_tmrecover)
0712 {
0713     int ret;
0714     ret=system_dbg("test089_tmrecover/run.sh");
0715     assert_equal(ret, EXSUCCEED);
0716 }
0717
0718 Ensure(test090_tuxmig)
0719 {
0720     int ret;
0721     ret=system_dbg("test090_tuxmig/run.sh");
0722 }
0723
0724 Ensure(test091_tpgotsig)
0725 {
0726     int ret;
0727     ret=system_dbg("test091_tpgotsig/run.sh");
0728     assert_equal(ret, EXSUCCEED);
0729 }
0730
0731 Ensure(test092_bflag)
0732 {
0733     int ret;
0734     ret=system_dbg("test092_bflag/run.sh");
0735     assert_equal(ret, EXSUCCEED);
0736 }
0737
0738 Ensure(test093_killseq)
0739 {
0740     int ret;
0741     ret=system_dbg("test093_killseq/run.sh");
0742     assert_equal(ret, EXSUCCEED);
0743 }
0744
0745 Ensure(test094_sigchld)
0746 {
0747     int ret;
0748     ret=system_dbg("test094_sigchld/run.sh");
0749     assert_equal(ret, EXSUCCEED);
0750 }
0751
0752 Ensure(test095_rqaddrel)
0753 {
0754     int ret;
0755     ret=system_dbg("test095_rqaddrel/run.sh");
0756     assert_equal(ret, EXSUCCEED);
0757 }
0758
0759 Ensure(test096_svcrmnet)
0760 {
0761     int ret;
0762     ret=system_dbg("test096_svcrmnet/run.sh");
0763     assert_equal(ret, EXSUCCEED);
0764 }
0765
0766 Ensure(test097_mtnojump)
0767 {
0768     int ret;
0769     ret=system_dbg("test097_mtnojump/run.sh");
0770     assert_equal(ret, EXSUCCEED);
0771 }
0772
0773 Ensure(test098_svqhkeep)
0774 {
0775     int ret;
0776     ret=system_dbg("test098_svqhkeep/run.sh");
0777     assert_equal(ret, EXSUCCEED);
0778 }
0779
0780 Ensure(test099_callbuflen)
0781 {
0782     int ret;
0783     ret=system_dbg("test099_callbuflen/run.sh");
0784     assert_equal(ret, EXSUCCEED);
0785 }
0786
0787
0788 Ensure(test100_svstdout)
0789 {
0790     int ret;
0791     ret=system_dbg("test100_svstdout/run.sh");
0792     assert_equal(ret, EXSUCCEED);
0793 }
0794
0795 Ensure(test101_dupsrv)
0796 {
0797     int ret;
0798     ret=system_dbg("test101_dupsrv/run.sh");
0799     assert_equal(ret, EXSUCCEED);
0800 }
0801
0802 Ensure(test102_procgrp)
0803 {
0804     int ret;
0805     ret=system_dbg("test102_procgrp/run.sh");
0806     assert_equal(ret, EXSUCCEED);
0807 }
0808
0809 Ensure(test103_singlegrp)
0810 {
0811     int ret;
0812     ret=system_dbg("test103_singlegrp/run.sh");
0813     assert_equal(ret, EXSUCCEED);
0814 }
0815
0816 Ensure(test104_tmqfailover)
0817 {
0818     int ret;
0819     ret=system_dbg("test104_tmqfailover/run.sh");
0820     assert_equal(ret, EXSUCCEED);
0821 }
0822
0823 Ensure(test105_respawn)
0824 {
0825     int ret;
0826     ret=system_dbg("test105_respawn/run.sh");
0827     assert_equal(ret, EXSUCCEED);
0828 }
0829
0830 Ensure(test106_periodcb)
0831 {
0832     int ret;
0833     ret=system_dbg("test106_periodcb/run.sh");
0834     assert_equal(ret, EXSUCCEED);
0835 }
0836
0837 Ensure(test107_tmsrvhkeep)
0838 {
0839     int ret;
0840     ret=system_dbg("test107_tmsrvhkeep/run.sh");
0841     assert_equal(ret, EXSUCCEED);
0842 }
0843
0844 TestSuite *atmi_test_all(void)
0845 {
0846     TestSuite *suite = create_test_suite();
0847     add_test(suite, test000_system);
0848     add_test(suite, test000_system_atmiunit0);
0849
0850     add_test(suite, test001_basiccall);
0851     add_test(suite, test002_basicforward);
0852     add_test(suite, test003_basicconvers);
0853     add_test(suite, test004_basicevent);
0854     add_test(suite, test005_convconfload);
0855     add_test(suite, test006_ulog);
0856     add_test(suite, test007_advertise);
0857     add_test(suite, test008_extensions);
0858     add_test(suite, test009_srvdie);
0859     add_test(suite, test010_strtracecond);
0860     add_test(suite, test011_tout);
0861
0862 #ifndef EX_OS_CYGWIN
0863 #ifdef SYS64BIT
0864     /* We should skip this on non 64bit machines! */
0865     add_test(suite, test012_admqfull);
0866 #endif
0867 #endif
0868
0869     add_test(suite, test001_basiccall_dom);
0870     add_test(suite, test002_basicforward_dom);
0871     add_test(suite, test003_basicconvers_dom);
0872     add_test(suite, test004_basicevent_dom);
0873     add_test(suite, test013_procnorsp);
0874     add_test(suite, test015_threads);
0875     add_test(suite, test017_srvthread);
0876     add_test(suite, test018_tpacalltout);
0877     add_test(suite, test021_xafull);
0878     add_test(suite, test022_typedstring);
0879     add_test(suite, test023_typedcarray);
0880     add_test(suite, test024_json);
0881     add_test(suite, test025_cpmsrv);
0882     add_test(suite, test026_typedjson);
0883 #ifndef NDRX_DISABLEPSCRIPT
0884     add_test(suite, test027_pscript);
0885 #endif
0886     add_test(suite, test028_tmq);
0887     add_test(suite, test029_inicfg);
0888     add_test(suite, test030_cconfsrv);
0889     add_test(suite, test031_logging);
0890     add_test(suite, test032_oapi);
0891
0892 #ifndef NDRX_DISABLEPSCRIPT
0893     add_test(suite, test033_provision);
0894 #endif
0895
0896     /* Feature #139 mvitolin, 09/05/2017 */
0897     add_test(suite, test034_shmreuse);
0898
0899     /* mvitolin Bug #112, 18/05/2017 */
0900     add_test(suite, test035_hkeep);
0901     /* mvitolin Bug #110, 22/05/2017 */
0902     add_test(suite, test036_tprecover);
0903
0904     /* Bug #133 */
0905     add_test(suite, test037_down);
0906
0907     add_test(suite, test038_tpnotify);
0908     add_test(suite, test039_tpbroadcast);
0909
0910     add_test(suite, test040_typedview);
0911
0912     add_test(suite, test040_typedview_dom);
0913
0914 #ifdef SYS64BIT
0915 #if defined(EX_OS_LINUX)
0916     add_test(suite, test041_bigmsg);
0917     add_test(suite,test042_bignet);
0918 #endif
0919 #endif
0920
0921     add_test(suite,test043_encrypt);
0922     add_test(suite,test044_ping);
0923     add_test(suite,test045_tpcallnoblock);
0924     add_test(suite,test046_twopasscfg);
0925 #ifdef NDRX_ENABLE_TEST47
0926     add_test(suite,test047_oradb);
0927 #endif
0928     add_test(suite,test048_cache);
0929     add_test(suite,test049_masksvc);
0930     add_test(suite,test050_ubfdb);
0931     add_test(suite,test051_settout);
0932     add_test(suite,test052_minstart);
0933     add_test(suite,test053_logoff);
0934     add_test(suite,test054_svwrap);
0935     add_test(suite,test055_envs);
0936     add_test(suite,test056_tpimpexp);
0937     add_test(suite,test057_invlcmd);
0938
0939 #ifdef EX_USE_SYSVQ
0940     /* for SVAPOLL not needed, as no rqaddr principle */
0941     add_test(suite, test058_systemv);
0942 #endif
0943
0944     add_test(suite, test059_pq);
0945     add_test(suite, test060_ndxdfork);
0946     add_test(suite, test061_ndxddup);
0947 /* for sanitizer the memory layout does not match the
0948  * test cases, thus cannot test...
0949  */
0950 #ifndef NDRX_SANITIZE
0951 /* seems like we get incorrect vms readings ... */
0952 #ifndef EX_OS_DARWIN
0953     add_test(suite, test062_memlimits);
0954 #endif
0955 #endif
0956     add_test(suite, test063_cpmrange);
0957     add_test(suite, test064_bufswitch);
0958     add_test(suite, test065_tpcancel);
0959     add_test(suite, test066_tmstartserver);
0960
0961 #ifdef NDRX_USE_POSTGRES
0962     add_test(suite, test067_postgres);
0963 #endif
0964
0965     add_test(suite, test068_tpadm);
0966     add_test(suite, test069_wnormal);
0967     add_test(suite, test070_ubfhook);
0968     add_test(suite, test071_buildtools);
0969     add_test(suite, test072_qos);
0970     add_test(suite, test073_netact);
0971
0972 /* really queues may lock-up or corrupt
0973  * if crash testing is performed
0974  */
0975 #ifndef EX_USE_EMQ
0976     add_test(suite, test074_sanitulog);
0977 #endif
0978
0979     add_test(suite, test075_dispthread);
0980     add_test(suite, test076_dispthreadxa);
0981     add_test(suite, test077_diedslowstrt);
0982     add_test(suite, test078_tpacallmix);
0983     add_test(suite, test079_cliquote);
0984     add_test(suite, test080_tpexit);
0985     add_test(suite, test081_lcf);
0986     add_test(suite, test082_autotran);
0987     add_test(suite, test083_ddrsyntax);
0988     add_test(suite, test084_ddr);
0989     add_test(suite, test085_prio);
0990
0991 /* really queues may lock-up or corrupt
0992  * if crash testing is performed
0993  */
0994 #ifndef EX_USE_EMQ
0995     /* EMQ does not support Q struct lock recovery from crashes */
0996     add_test(suite, test086_tmqlimit);
0997     add_test(suite, test087_tmsrv);
0998 #endif
0999     add_test(suite, test088_addlog);
1000     add_test(suite, test089_tmrecover);
1001     add_test(suite, test090_tuxmig);
1002
1003 #ifdef EX_USE_EPOLL
1004     add_test(suite, test091_tpgotsig);
1005 #endif
1006
1007     add_test(suite, test092_bflag);
1008     add_test(suite, test093_killseq);
1009     add_test(suite, test094_sigchld);
1010 #ifdef EX_USE_SYSVQ
1011     add_test(suite, test095_rqaddrel);
1012 #endif
1013
1014     /* for systemv each binary have request q, on mac cannot test as
1015      * missing robust mutex might cause system lockup
1016      */
1017 #if defined(EX_USE_EPOLL)|| defined(EX_USE_SVAPOLL) || defined(EX_USE_KQUEUE)
1018     add_test(suite, test096_svcrmnet);
1019 #endif
1020     add_test(suite, test097_mtnojump);
1021
1022     add_test(suite, test098_svqhkeep);
1023     add_test(suite, test099_callbuflen);
1024     add_test(suite, test100_svstdout);
1025     add_test(suite, test101_dupsrv);
1026     add_test(suite, test102_procgrp);
1027 #ifndef EX_USE_EMQ
1028     add_test(suite, test103_singlegrp);
1029     add_test(suite, test104_tmqfailover);
1030 #endif
1031     add_test(suite, test105_respawn);
1032     add_test(suite, test106_periodcb);
1033     add_test(suite, test107_tmsrvhkeep);
1034
1035
1036     return suite;
1037 }
1038
1039 /**
1040  * Main test case entry
1041  */
1042 int main(int argc, char** argv) {
1043
1044     int ret;
1045
1046     TestSuite *suite = create_test_suite();
1047
1048     add_suite(suite, atmi_test_all());
1049
1050
1051     if (argc > 1)
1052     {
1053         ret=run_single_test(suite,argv[1],create_text_reporter());
1054     }
1055     else
1056     {
1057         ret=run_test_suite(suite, create_text_reporter());
1058     }
1059
1060     destroy_test_suite(suite);
1061
1062     return ret;
1063 }
1064
1065 /* vim: set ts=4 sw=4 et smartindent: */