1: %% 2: %% %CopyrightBegin% 3: %% 4: %% Copyright Ericsson AB 2004-2011. All Rights Reserved. 5: %% 6: %% The contents of this file are subject to the Erlang Public License, 7: %% Version 1.1, (the "License"); you may not use this file except in 8: %% compliance with the License. You should have received a copy of the 9: %% Erlang Public License along with this software. If not, it can be 10: %% retrieved online at http://www.erlang.org/. 11: %% 12: %% Software distributed under the License is distributed on an "AS IS" 13: %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See 14: %% the License for the specific language governing rights and limitations 15: %% under the License. 16: %% 17: %% %CopyrightEnd% 18: %% 19: %% 20: %%----------------------------------------------------------------- 21: %% 22: %% Description: 23: %% Test suite for the basic typecode functions 24: %% 25: %%----------------------------------------------------------------- 26: -module(tc_SUITE). 27: 28: -include_lib("test_server/include/test_server.hrl"). 29: -include_lib("orber/src/orber_iiop.hrl"). 30: 31: -define(default_timeout, ?t:minutes(3)). 32: 33: -define(match(Expr), 34: fun() -> 35: case (catch (Expr)) of 36: AcTuAlReS when is_binary(AcTuAlReS)-> 37: io:format("###### ERROR ERROR ######~nRESULT: ~p~n", 38: [AcTuAlReS]), 39: exit(AcTuAlReS); 40: _ -> 41: ok 42: end 43: end()). 44: -define(SUB_ELIST, [{"null", orber_tc:null()}, 45: {"void", orber_tc:void()}, 46: {"short", orber_tc:short()}, 47: {"unsigned_short", orber_tc:unsigned_short()}, 48: {"long", orber_tc:long()}, 49: {"unsigned_long", orber_tc:unsigned_long()}, 50: {"long_long", orber_tc:long_long()}, 51: {"unsigned_long_long", orber_tc:unsigned_long_long()}, 52: {"float", orber_tc:'float'()}, 53: {"double", orber_tc:double()}, 54: {"longdouble", orber_tc:longdouble()}, 55: {"boolean", orber_tc:boolean()}, 56: {"char", orber_tc:char()}, 57: {"wchar", orber_tc:wchar()}, 58: {"octet", orber_tc:octet()}, 59: {"any", orber_tc:any()}, 60: {"typecode", orber_tc:typecode()}, 61: {"principal", orber_tc:principal()}, 62: {"object_reference", orber_tc:object_reference("Id", "Name")}]). 63: 64: -define(ELIST, [{"null", orber_tc:null()}, 65: {"void", orber_tc:void()}, 66: {"short", orber_tc:short()}, 67: {"unsigned_short", orber_tc:unsigned_short()}, 68: {"long", orber_tc:long()}, 69: {"unsigned_long", orber_tc:unsigned_long()}, 70: {"long_long", orber_tc:long_long()}, 71: {"unsigned_long_long", orber_tc:unsigned_long_long()}, 72: {"float", orber_tc:'float'()}, 73: {"double", orber_tc:double()}, 74: {"longdouble", orber_tc:longdouble()}, 75: {"boolean", orber_tc:boolean()}, 76: {"char", orber_tc:char()}, 77: {"wchar", orber_tc:wchar()}, 78: {"octet", orber_tc:octet()}, 79: {"any", orber_tc:any()}, 80: {"typecode", orber_tc:typecode()}, 81: {"principal", orber_tc:principal()}, 82: {"object_reference", orber_tc:object_reference("Id", "Name")}, 83: {"struct", orber_tc:struct("Id", "Name", ?SUB_ELIST)}, 84: {"enum", orber_tc:enum("Id", "Name", ["E1", "E2"])}, 85: {"string", orber_tc:string(1)}, 86: {"wstring", orber_tc:wstring(0)}, 87: {"sequence", orber_tc:sequence(orber_tc:enum("Id", "Name", 88: ["E1", "E2"]), 0)}, 89: {"array", orber_tc:array(orber_tc:enum("Id", "Name", 90: ["E1", "E2"]), 2)}, 91: {"alias", orber_tc:alias("id", "name", 92: orber_tc:enum("Id", "Name", 93: ["E1", "E2"]))}, 94: {"exception", orber_tc:exception("Id", "Name", ?SUB_ELIST)}]). 95: 96: -define(VELIST, [{"null", orber_tc:null(), 42}, 97: {"void", orber_tc:void(), 42}, 98: {"short", orber_tc:short(), 42}, 99: {"unsigned_short", orber_tc:unsigned_short(), 42}, 100: {"long", orber_tc:long(), 42}, 101: {"unsigned_long", orber_tc:unsigned_long(), 42}, 102: {"long_long", orber_tc:long_long(), 42}, 103: {"unsigned_long_long", orber_tc:unsigned_long_long(), 42}, 104: {"float", orber_tc:'float'(), 42}, 105: {"double", orber_tc:double(), 42}, 106: {"longdouble", orber_tc:longdouble(), 42}, 107: {"boolean", orber_tc:boolean(), 42}, 108: {"char", orber_tc:char(), 42}, 109: {"wchar", orber_tc:wchar(), 42}, 110: {"octet", orber_tc:octet(), 42}, 111: {"any", orber_tc:any(), 42}, 112: {"typecode", orber_tc:typecode(), 42}, 113: {"principal", orber_tc:principal(), 42}, 114: {"object_reference", orber_tc:object_reference("Id", "Name"), 42}, 115: {"struct", orber_tc:struct("Id", "Name", ?SUB_ELIST), 42}, 116: {"enum", orber_tc:enum("Id", "Name", ["E1", "E2"]), 42}, 117: {"string", orber_tc:string(1), 42}, 118: {"wstring", orber_tc:wstring(0), 42}, 119: {"sequence", orber_tc:sequence(orber_tc:enum("Id", "Name", 120: ["E1", "E2"]), 0), 42}, 121: {"array", orber_tc:array(orber_tc:enum("Id", "Name", 122: ["E1", "E2"]), 2), 42}, 123: {"alias", orber_tc:alias("id", "name", 124: orber_tc:enum("Id", "Name", 125: ["E1", "E2"])), 42}, 126: {"exception", orber_tc:exception("Id", "Name", ?SUB_ELIST), 42}]). 127: 128: %%----------------------------------------------------------------- 129: %% External exports 130: %%----------------------------------------------------------------- 131: -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 132: init_per_group/2,end_per_group/2]). 133: 134: %%----------------------------------------------------------------- 135: %% Internal exports 136: %%----------------------------------------------------------------- 137: -compile(export_all). 138: 139: %%----------------------------------------------------------------- 140: %% Func: all/1 141: %% Args: 142: %% Returns: 143: %%----------------------------------------------------------------- 144: suite() -> [{ct_hooks,[ts_install_cth]}]. 145: 146: all() -> 147: [null, void, short, ushort, long, ulong, longlong, 148: ulonglong, boolean, char, wchar, octet, float, double, 149: longdouble, any, typecode, principal, object_reference, 150: struct, union, enum, string, wstring, sequence, array, 151: alias, exception, fixed, value, value_box, native, 152: abstract_interface, indirection, get_tc]. 153: 154: groups() -> 155: []. 156: 157: init_per_suite(Config) -> 158: Config. 159: 160: end_per_suite(_Config) -> 161: ok. 162: 163: init_per_group(_GroupName, Config) -> 164: Config. 165: 166: end_per_group(_GroupName, Config) -> 167: Config. 168: 169: 170: %%----------------------------------------------------------------- 171: %% Init and cleanup functions. 172: %%----------------------------------------------------------------- 173: 174: init_per_testcase(_Case, Config) -> 175: ?line Dog=test_server:timetrap(?default_timeout), 176: [{watchdog, Dog}|Config]. 177: 178: 179: end_per_testcase(_Case, Config) -> 180: Dog = ?config(watchdog, Config), 181: test_server:timetrap_cancel(Dog), 182: ok. 183: 184: %%----------------------------------------------------------------- 185: %% Test Case: null test 186: %% Description: 187: %%----------------------------------------------------------------- 188: null(doc) -> []; 189: null(suite) -> []; 190: null(_) -> 191: ?line true = orber_tc:check_tc(orber_tc:null()), 192: ?line code(orber_tc:null()), 193: ok. 194: 195: %%----------------------------------------------------------------- 196: %% Test Case: void test 197: %% Description: 198: %%----------------------------------------------------------------- 199: void(doc) -> []; 200: void(suite) -> []; 201: void(_) -> 202: ?line true = orber_tc:check_tc(orber_tc:void()), 203: ?line code(orber_tc:void()), 204: ok. 205: 206: %%----------------------------------------------------------------- 207: %% Test Case: short integer test 208: %% Description: 209: %%----------------------------------------------------------------- 210: short(doc) -> []; 211: short(suite) -> []; 212: short(_) -> 213: ?line true = orber_tc:check_tc(orber_tc:short()), 214: ?line code(orber_tc:short()), 215: ok. 216: 217: %%----------------------------------------------------------------- 218: %% Test Case: unsigned short integer test 219: %% Description: 220: %%----------------------------------------------------------------- 221: ushort(doc) -> []; 222: ushort(suite) -> []; 223: ushort(_) -> 224: ?line true = orber_tc:check_tc(orber_tc:unsigned_short()), 225: ?line code(orber_tc:unsigned_short()), 226: ok. 227: 228: %%----------------------------------------------------------------- 229: %% Test Case: long integer test 230: %% Description: 231: %%----------------------------------------------------------------- 232: long(doc) -> []; 233: long(suite) -> []; 234: long(_) -> 235: ?line true = orber_tc:check_tc(orber_tc:long()), 236: ?line code(orber_tc:long()), 237: ok. 238: 239: %%----------------------------------------------------------------- 240: %% Test Case: unsigned long integer test 241: %% Description: 242: %%----------------------------------------------------------------- 243: ulong(doc) -> []; 244: ulong(suite) -> []; 245: ulong(_) -> 246: ?line true = orber_tc:check_tc(orber_tc:unsigned_long()), 247: ?line code(orber_tc:unsigned_long()), 248: ok. 249: 250: 251: %%----------------------------------------------------------------- 252: %% Test Case: long integer test 253: %% Description: 254: %%----------------------------------------------------------------- 255: longlong(doc) -> []; 256: longlong(suite) -> []; 257: longlong(_) -> 258: ?line true = orber_tc:check_tc(orber_tc:long_long()), 259: ?line code(orber_tc:long_long()), 260: ok. 261: 262: %%----------------------------------------------------------------- 263: %% Test Case: unsigned long integer test 264: %% Description: 265: %%----------------------------------------------------------------- 266: ulonglong(doc) -> []; 267: ulonglong(suite) -> []; 268: ulonglong(_) -> 269: ?line true = orber_tc:check_tc(orber_tc:unsigned_long_long()), 270: ?line code(orber_tc:unsigned_long_long()), 271: ok. 272: 273: 274: %%----------------------------------------------------------------- 275: %% Test Case: float test 276: %% Description: 277: %%----------------------------------------------------------------- 278: float(doc) -> []; 279: float(suite) -> []; 280: float(_) -> 281: ?line true = orber_tc:check_tc(orber_tc:'float'()), 282: ?line code(orber_tc:'float'()), 283: ok. 284: 285: %%----------------------------------------------------------------- 286: %% Test Case: double test 287: %% Description: 288: %%----------------------------------------------------------------- 289: double(doc) -> []; 290: double(suite) -> []; 291: double(_) -> 292: ?line true = orber_tc:check_tc(orber_tc:double()), 293: ?line code(orber_tc:double()), 294: ok. 295: 296: %%----------------------------------------------------------------- 297: %% Test Case: longdouble test 298: %% Description: 299: %%----------------------------------------------------------------- 300: longdouble(doc) -> []; 301: longdouble(suite) -> []; 302: longdouble(_) -> 303: ?line true = orber_tc:check_tc(orber_tc:longdouble()), 304: ?line code(orber_tc:longdouble()), 305: ok. 306: 307: %%----------------------------------------------------------------- 308: %% Test Case: boolean test 309: %% Description: 310: %%----------------------------------------------------------------- 311: boolean(doc) -> []; 312: boolean(suite) -> []; 313: boolean(_) -> 314: ?line true = orber_tc:check_tc(orber_tc:boolean()), 315: ?line code(orber_tc:boolean()), 316: ok. 317: 318: %%----------------------------------------------------------------- 319: %% Test Case: character test 320: %% Description: 321: %%----------------------------------------------------------------- 322: char(doc) -> []; 323: char(suite) -> []; 324: char(_) -> 325: ?line true = orber_tc:check_tc(orber_tc:char()), 326: ?line code(orber_tc:char()), 327: ok. 328: 329: %%----------------------------------------------------------------- 330: %% Test Case: character test 331: %% Description: 332: %%----------------------------------------------------------------- 333: wchar(doc) -> []; 334: wchar(suite) -> []; 335: wchar(_) -> 336: ?line true = orber_tc:check_tc(orber_tc:wchar()), 337: ?line code(orber_tc:wchar()), 338: ok. 339: 340: %%----------------------------------------------------------------- 341: %% Test Case: octet test 342: %% Description: 343: %%----------------------------------------------------------------- 344: octet(doc) -> []; 345: octet(suite) -> []; 346: octet(_) -> 347: ?line true = orber_tc:check_tc(orber_tc:octet()), 348: ?line code(orber_tc:octet()), 349: ok. 350: 351: %%----------------------------------------------------------------- 352: %% Test Case: any test 353: %% Description: 354: %%----------------------------------------------------------------- 355: any(doc) -> []; 356: any(suite) -> []; 357: any(_) -> 358: ?line true = orber_tc:check_tc(orber_tc:any()), 359: ?line code(orber_tc:any()), 360: ok. 361: 362: %%----------------------------------------------------------------- 363: %% Test Case: typecode test 364: %% Description: 365: %%----------------------------------------------------------------- 366: typecode(doc) -> []; 367: typecode(suite) -> []; 368: typecode(_) -> 369: ?line true = orber_tc:check_tc(orber_tc:typecode()), 370: ?line code(orber_tc:typecode()), 371: ok. 372: 373: %%----------------------------------------------------------------- 374: %% Test Case: principal test 375: %% Description: 376: %%----------------------------------------------------------------- 377: principal(doc) -> []; 378: principal(suite) -> []; 379: principal(_) -> 380: ?line true = orber_tc:check_tc(orber_tc:principal()), 381: ?line code(orber_tc:principal()), 382: ok. 383: 384: 385: %%----------------------------------------------------------------- 386: %% Test Case: object_reference test 387: %% Description: 388: %%----------------------------------------------------------------- 389: object_reference(doc) -> []; 390: object_reference(suite) -> []; 391: object_reference(_) -> 392: ?line true = orber_tc:check_tc(orber_tc:object_reference("Id", "Name")), 393: ?line false = orber_tc:check_tc(orber_tc:object_reference(42, "Name")), 394: ?line false = orber_tc:check_tc(orber_tc:object_reference("Id", 42)), 395: ?line code(orber_tc:object_reference("Id", "Name")), 396: ?line ?match(code(orber_tc:object_reference(42, "Name"))), 397: ?line ?match(code(orber_tc:object_reference("Id", 42))), 398: ok. 399: 400: %%----------------------------------------------------------------- 401: %% Test Case: struct 402: %% Description: 403: %%----------------------------------------------------------------- 404: struct(doc) -> []; 405: struct(suite) -> []; 406: struct(_) -> 407: ?line true = orber_tc:check_tc(orber_tc:struct("Id", "Name", ?ELIST)), 408: ?line false = orber_tc:check_tc(orber_tc:struct(42, "Name", ?ELIST)), 409: ?line false = orber_tc:check_tc(orber_tc:struct("Id", false, ?ELIST)), 410: ?line false = orber_tc:check_tc(orber_tc:struct("Id", "Name", ?VELIST)), 411: ?line false = orber_tc:check_tc(orber_tc:struct("Id", "Name", "wrong")), 412: ?line code(orber_tc:struct("Id", "Name", ?ELIST)), 413: ?line ?match(code(orber_tc:struct(42, "Name", ?ELIST))), 414: ?line ?match(code(orber_tc:struct("Id", false, ?ELIST))), 415: ?line ?match(code(orber_tc:struct("Id", "Name", ?VELIST))), 416: ?line ?match(code(orber_tc:struct("Id", "Name", "wrong"))), 417: ok. 418: 419: %%----------------------------------------------------------------- 420: %% Test Case: union 421: %% Description: 422: %%----------------------------------------------------------------- 423: union(doc) -> []; 424: union(suite) -> []; 425: union(_) -> 426: ?line true = orber_tc:check_tc(orber_tc:union("Id", "Name", orber_tc:long(), 427: -1, [{1, "long", orber_tc:long()}, 428: {2, "longlong", orber_tc:long()}])), 429: ?line false = orber_tc:check_tc(orber_tc:union("Id", "Name", orber_tc:long(), 430: -1, ?ELIST)), 431: ?line false = orber_tc:check_tc(orber_tc:union(42, "Name", orber_tc:long(), 432: -1, [{1, "long", orber_tc:long()}, 433: {2, "longlong", orber_tc:long()}])), 434: ?line false = orber_tc:check_tc(orber_tc:union("Id", false, orber_tc:long(), 435: -1, [{1, "long", orber_tc:long()}, 436: {2, "longlong", orber_tc:long()}])), 437: ?line false = orber_tc:check_tc(orber_tc:union("Id", "Name", bad_tc, 438: -1, [{1, "long", orber_tc:long()}, 439: {2, "longlong", orber_tc:long()}])), 440: ?line false = orber_tc:check_tc(orber_tc:union("Id", "Name", orber_tc:long(), 441: "wrong", [{1, "long", orber_tc:long()}, 442: {2, "longlong", orber_tc:long()}])), 443: 444: ?line code(orber_tc:union("Id", "Name", orber_tc:long(), 445: -1, [{1, "long", orber_tc:long()}, 446: {2, "longlong", orber_tc:long()}])), 447: ok. 448: 449: 450: %%----------------------------------------------------------------- 451: %% Test Case: enum test 452: %% Description: 453: %%----------------------------------------------------------------- 454: enum(doc) -> []; 455: enum(suite) -> []; 456: enum(_) -> 457: ?line true = orber_tc:check_tc(orber_tc:enum("Id", "Name", 458: ["E1", "E2", "E3"])), 459: ?line false = orber_tc:check_tc(orber_tc:enum(42, "Name", 460: ["E1", "E2", "E3"])), 461: ?line false = orber_tc:check_tc(orber_tc:enum("Id", false, 462: ["E1", "E2", "E3"])), 463: ?line false = orber_tc:check_tc(orber_tc:enum("Id", "Name", 464: ["E1", false, "E3"])), 465: ?line code(orber_tc:enum("Id", "Name", ["E1", "E2", "E3"])), 466: ?line ?match(code(orber_tc:enum(false, "Name", ["E1", "E2", "E3"]))), 467: ?line ?match(code(orber_tc:enum("Id", 42, ["E1", "E2", "E3"]))), 468: ?line ?match(code(orber_tc:enum("Id", "Name", ["E1", false, "E3"]))), 469: ok. 470: 471: %%----------------------------------------------------------------- 472: %% Test Case: string 473: %% Description: 474: %%----------------------------------------------------------------- 475: string(doc) -> []; 476: string(suite) -> []; 477: string(_) -> 478: ?line true = orber_tc:check_tc(orber_tc:string(0)), 479: ?line true = orber_tc:check_tc(orber_tc:string(1)), 480: ?line false = orber_tc:check_tc(orber_tc:string("wrong")), 481: ?line code(orber_tc:string(0)), 482: ?line code(orber_tc:string(1)), 483: ?line ?match(code(orber_tc:string(-1))), 484: ?line ?match(code(orber_tc:string(?ULONGMAX+1))), 485: ?line ?match(code(orber_tc:string("wrong"))), 486: ok. 487: 488: %%----------------------------------------------------------------- 489: %% Test Case: wstring 490: %% Description: 491: %%----------------------------------------------------------------- 492: wstring(doc) -> []; 493: wstring(suite) -> []; 494: wstring(_) -> 495: ?line true = orber_tc:check_tc(orber_tc:wstring(0)), 496: ?line true = orber_tc:check_tc(orber_tc:wstring(1)), 497: ?line false = orber_tc:check_tc(orber_tc:wstring("wrong")), 498: ?line code(orber_tc:wstring(0)), 499: ?line code(orber_tc:wstring(1)), 500: ?line ?match(code(orber_tc:wstring(-1))), 501: ?line ?match(code(orber_tc:wstring(?ULONGMAX+1))), 502: ?line ?match(code(orber_tc:wstring(false))), 503: ok. 504: 505: %%----------------------------------------------------------------- 506: %% Test Case: sequence 507: %% Description: 508: %%----------------------------------------------------------------- 509: sequence(doc) -> []; 510: sequence(suite) -> []; 511: sequence(_) -> 512: ?line true = orber_tc:check_tc(orber_tc:sequence(orber_tc:struct("Id", "Name", ?ELIST), 0)), 513: ?line code(orber_tc:sequence(orber_tc:struct("Id", "Name", ?ELIST), 0)), 514: ok. 515: 516: %%----------------------------------------------------------------- 517: %% Test Case: array 518: %% Description: 519: %%----------------------------------------------------------------- 520: array(doc) -> []; 521: array(suite) -> []; 522: array(_) -> 523: ?line true = orber_tc:check_tc(orber_tc:array(orber_tc:struct("Id", "Name", ?ELIST), 1)), 524: ?line code(orber_tc:array(orber_tc:struct("Id", "Name", ?ELIST), 1)), 525: ok. 526: 527: %%----------------------------------------------------------------- 528: %% Test Case: alias 529: %% Description: 530: %%----------------------------------------------------------------- 531: alias(doc) -> []; 532: alias(suite) -> []; 533: alias(_) -> 534: ?line true = orber_tc:check_tc(orber_tc:alias("Id", "Name", orber_tc:struct("Id", "Name", ?ELIST))), 535: ?line false = orber_tc:check_tc(orber_tc:alias(false, "Name", orber_tc:struct("Id", "Name", ?ELIST))), 536: ?line false = orber_tc:check_tc(orber_tc:alias("Id", 42, orber_tc:struct("Id", "Name", ?ELIST))), 537: ?line false = orber_tc:check_tc(orber_tc:alias("Id", "Name", "wrong")), 538: ?line code(orber_tc:alias("Id", "Name", orber_tc:struct("Id", "Name", ?ELIST))), 539: ?line ?match(code(orber_tc:alias("Id", "Name", orber_tc:struct("Id", "Name", ?VELIST)))), 540: ok. 541: 542: %%----------------------------------------------------------------- 543: %% Test Case: exception 544: %% Description: 545: %%----------------------------------------------------------------- 546: exception(doc) -> []; 547: exception(suite) -> []; 548: exception(_) -> 549: ?line true = orber_tc:check_tc(orber_tc:exception("Id", "Name", ?ELIST)), 550: ?line false = orber_tc:check_tc(orber_tc:exception(42, "Name", ?ELIST)), 551: ?line false = orber_tc:check_tc(orber_tc:exception("Id", false, ?ELIST)), 552: ?line false = orber_tc:check_tc(orber_tc:exception("Id", "Name", "wrong")), 553: ?line code(orber_tc:exception("Id", "Name", ?ELIST)), 554: ?line ?match(code(orber_tc:exception(42, "Name", ?ELIST))), 555: ?line ?match(code(orber_tc:exception("Id", false, ?ELIST))), 556: ?line ?match(code(orber_tc:exception("Id", "Name", "wrong"))), 557: 558: ok. 559: 560: %%----------------------------------------------------------------- 561: %% Test Case: fixed 562: %% Description: 563: %%----------------------------------------------------------------- 564: fixed(doc) -> []; 565: fixed(suite) -> []; 566: fixed(_) -> 567: ?line true = orber_tc:check_tc(orber_tc:fixed(25, 2)), 568: ?line code(orber_tc:fixed(25, 2)), 569: ok. 570: 571: %%----------------------------------------------------------------- 572: %% Test Case: value 573: %% Description: 574: %%----------------------------------------------------------------- 575: value(doc) -> []; 576: value(suite) -> []; 577: value(_) -> 578: ?line true = orber_tc:check_tc(orber_tc:value("Id", "Name", 42, 579: orber_tc:fixed(25, 2), ?VELIST)), 580: ?line false = orber_tc:check_tc(orber_tc:value(42, "Name", 42, 581: orber_tc:fixed(25, 2), ?VELIST)), 582: ?line false = orber_tc:check_tc(orber_tc:value("Id", 42, 42, 583: orber_tc:fixed(25, 2), ?VELIST)), 584: ?line false = orber_tc:check_tc(orber_tc:value("Id", "Name", "wrong", 585: orber_tc:fixed(25, 2), ?VELIST)), 586: ?line false = orber_tc:check_tc(orber_tc:value("Id", "Name", "42", 587: orber_tc:fixed(25, 2), ?VELIST)), 588: ?line false = orber_tc:check_tc(orber_tc:value("Id", "Name", "42", 589: ?VELIST, ?VELIST)), 590: ?line false = orber_tc:check_tc(orber_tc:value("Id", "Name", "42", 591: orber_tc:fixed(25, 2), false)), 592: 593: ?line code(orber_tc:value("Id", "Name", 42, orber_tc:long(), ?VELIST)), 594: ok. 595: 596: %%----------------------------------------------------------------- 597: %% Test Case: value_box 598: %% Description: 599: %%----------------------------------------------------------------- 600: value_box(doc) -> []; 601: value_box(suite) -> []; 602: value_box(_) -> 603: ?line true = orber_tc:check_tc(orber_tc:value_box("Id", "Name", 604: orber_tc:fixed(25, 2))), 605: ?line false = orber_tc:check_tc(orber_tc:value_box(42, "Name", 606: orber_tc:fixed(25, 2))), 607: ?line false = orber_tc:check_tc(orber_tc:value_box("Id", 42, 608: orber_tc:fixed(25, 2))), 609: ?line false = orber_tc:check_tc(orber_tc:value_box("Id", "Name", "wrong")), 610: ?line code(orber_tc:value_box("Id", "Name", orber_tc:long())), 611: ?line ?match(code(orber_tc:value_box(42, "Name", orber_tc:short()))), 612: ?line ?match(code(orber_tc:value_box("Id", 42, orber_tc:char()))), 613: ?line ?match(code(orber_tc:value_box("Id", "Name", false))), 614: ok. 615: 616: %%----------------------------------------------------------------- 617: %% Test Case: native 618: %% Description: 619: %%----------------------------------------------------------------- 620: native(doc) -> []; 621: native(suite) -> []; 622: native(_) -> 623: ?line true = orber_tc:check_tc(orber_tc:native("Id", "Name")), 624: ?line false = orber_tc:check_tc(orber_tc:native(42, "Name")), 625: ?line false = orber_tc:check_tc(orber_tc:native("Id", 42)), 626: ?line code(orber_tc:native("Id", "Name")), 627: ?line ?match(code(orber_tc:native(42, "Name"))), 628: ?line ?match(code(orber_tc:native("Id", 42))), 629: ok. 630: 631: %%----------------------------------------------------------------- 632: %% Test Case: abstract_interface 633: %% Description: 634: %%----------------------------------------------------------------- 635: abstract_interface(doc) -> []; 636: abstract_interface(suite) -> []; 637: abstract_interface(_) -> 638: ?line true = orber_tc:check_tc(orber_tc:abstract_interface("RepId", "Name")), 639: ?line false = orber_tc:check_tc(orber_tc:abstract_interface(false, "Name")), 640: ?line false = orber_tc:check_tc(orber_tc:abstract_interface("RepId", 42)), 641: ?line code(orber_tc:abstract_interface("RepId", "Name")), 642: ?line ?match(code(orber_tc:abstract_interface(42, "Name"))), 643: ?line ?match(code(orber_tc:abstract_interface("Id", 42))), 644: ok. 645: 646: 647: 648: %%----------------------------------------------------------------- 649: %% Test Case: indirection 650: %% Description: 651: %%----------------------------------------------------------------- 652: indirection(doc) -> []; 653: indirection(suite) -> []; 654: indirection(_) -> 655: ?line true = orber_tc:check_tc({'none', 42}), 656: ok. 657: 658: %%----------------------------------------------------------------- 659: %% Test Case: get_tc 660: %% Description: 661: %%----------------------------------------------------------------- 662: get_tc(doc) -> []; 663: get_tc(suite) -> []; 664: get_tc(_) -> 665: TC = 'CosNaming_Binding':tc(), 666: ?line TC = orber_tc:get_tc({'CosNaming_Binding', 42}), 667: ?line ?match(orber_tc:get_tc({'none', 42})), 668: ok. 669: 670: %%----------------------------------------------------------------- 671: %% MISC Operations 672: %%----------------------------------------------------------------- 673: code(Value) -> 674: cdr_encode:enc_type({1,2}, tk_TypeCode, Value).