1% 2% Copyright (c) ZeroC, Inc. All rights reserved. 3% 4 5classdef AllTests 6 methods(Static) 7 function r = allTests(helper) 8 import Test.*; 9 10 communicator = helper.communicator(); 11 12 ref = ['initial:', helper.getTestEndpoint()]; 13 base = communicator.stringToProxy(ref); 14 initial = InitialPrx.checkedCast(base); 15 16 fprintf('testing optional data members... '); 17 18 oo1 = OneOptional(); 19 assert(oo1.a == Ice.Unset); 20 oo1.a = 15; 21 22 oo2 = OneOptional(16); 23 assert(oo2.a == 16); 24 25 mo1 = MultiOptional(); 26 assert(mo1.a == Ice.Unset); 27 assert(mo1.b == Ice.Unset); 28 assert(mo1.c == Ice.Unset); 29 assert(mo1.d == Ice.Unset); 30 assert(mo1.e == Ice.Unset); 31 assert(mo1.f == Ice.Unset); 32 assert(mo1.g == Ice.Unset); 33 assert(mo1.h == Ice.Unset); 34 assert(mo1.i == Ice.Unset); 35 assert(mo1.j == Ice.Unset); 36 assert(mo1.k == Ice.Unset); 37 assert(mo1.bs == Ice.Unset); 38 assert(mo1.ss == Ice.Unset); 39 assert(mo1.iid == Ice.Unset); 40 assert(mo1.sid == Ice.Unset); 41 assert(mo1.fs == Ice.Unset); 42 assert(mo1.vs == Ice.Unset); 43 44 assert(mo1.shs == Ice.Unset); 45 assert(mo1.es == Ice.Unset); 46 assert(mo1.fss == Ice.Unset); 47 assert(mo1.vss == Ice.Unset); 48 assert(mo1.oos == Ice.Unset); 49 assert(mo1.oops == Ice.Unset); 50 51 assert(mo1.ied == Ice.Unset); 52 assert(mo1.ifsd == Ice.Unset); 53 assert(mo1.ivsd == Ice.Unset); 54 assert(mo1.iood == Ice.Unset); 55 assert(mo1.ioopd == Ice.Unset); 56 57 assert(mo1.bos == Ice.Unset); 58 59 ss = SmallStruct(); 60 fs = FixedStruct(78); 61 vs = VarStruct('hello'); 62 iid = containers.Map('KeyType', 'int32', 'ValueType', 'int32'); 63 iid(4) = 3; 64 sid = containers.Map('KeyType', 'char', 'ValueType', 'int32'); 65 sid('test') = 10; 66 ied = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 67 ied(4) = MyEnum.MyEnumMember; 68 oos = {}; 69 oos{1} = oo1; 70 ifsd = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 71 ifsd(4) = fs; 72 ivsd = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 73 ivsd(5) = vs; 74 iood = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 75 iood(5) = OneOptional(15); 76 ioopd = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 77 ioopd(5) = communicator.stringToProxy('test'); 78 mo1 = MultiOptional(15, true, 19, 78, 99, 5.5, 1.0, 'test', MyEnum.MyEnumMember, ... 79 communicator.stringToProxy('test'), ... 80 [], [5], {'test', 'test2'}, iid, sid, fs, vs, [1], ... 81 [MyEnum.MyEnumMember, MyEnum.MyEnumMember], ... 82 [ fs ], [ vs ], oos, { communicator.stringToProxy('test') }, ... 83 ied, ifsd, ivsd, iood, ioopd, [false, true, false], []); 84 85 assert(mo1.a == 15); 86 assert(mo1.b == true); 87 assert(mo1.c == 19); 88 assert(mo1.d == 78); 89 assert(mo1.e == 99); 90 assert(mo1.f == 5.5); 91 assert(mo1.g == 1.0); 92 assert(strcmp(mo1.h, 'test')); 93 assert(mo1.i == MyEnum.MyEnumMember); 94 assert(mo1.j == communicator.stringToProxy('test')); 95 assert(isempty(mo1.k)); 96 assert(mo1.bs == [5]) 97 assert(isequal(mo1.ss, {'test', 'test2'})); 98 assert(mo1.iid(4) == 3); 99 assert(mo1.sid('test') == 10); 100 assert(isequal(mo1.fs, FixedStruct(78))); 101 assert(isequal(mo1.vs, VarStruct('hello'))); 102 103 assert(mo1.shs(1) == 1); 104 assert(mo1.es(1) == MyEnum.MyEnumMember && mo1.es(2) == MyEnum.MyEnumMember); 105 assert(isequal(mo1.fss(1), FixedStruct(78))); 106 assert(isequal(mo1.vss(1), VarStruct('hello'))); 107 assert(isequal(mo1.oos{1}, oo1)); 108 assert(mo1.oops{1} == communicator.stringToProxy('test')); 109 110 assert(mo1.ied(4) == MyEnum.MyEnumMember); 111 assert(isequal(mo1.ifsd(4), FixedStruct(78))); 112 assert(isequal(mo1.ivsd(5), VarStruct('hello'))); 113 assert(mo1.iood(5).a == 15); 114 assert(mo1.ioopd(5) == communicator.stringToProxy('test')); 115 116 assert(isequal(mo1.bos, [false, true, false])); 117 118 % 119 % Test generated struct and classes compare with Ice.Unset 120 % 121 assert(ss ~= Ice.Unset); 122 assert(fs ~= Ice.Unset); 123 assert(vs ~= Ice.Unset); 124 assert(mo1 ~= Ice.Unset); 125 126 fprintf('ok\n'); 127 128 fprintf('testing marshaling... '); 129 130 oo4 = initial.pingPong(OneOptional()); 131 assert(oo4.a == Ice.Unset); 132 133 oo5 = initial.pingPong(oo1); 134 assert(oo1.a == oo5.a); 135 136 mo4 = initial.pingPong(MultiOptional()); 137 assert(mo4.a == Ice.Unset); 138 assert(mo4.b == Ice.Unset); 139 assert(mo4.c == Ice.Unset); 140 assert(mo4.d == Ice.Unset); 141 assert(mo4.e == Ice.Unset); 142 assert(mo4.f == Ice.Unset); 143 assert(mo4.g == Ice.Unset); 144 assert(mo4.h == Ice.Unset); 145 assert(mo4.i == Ice.Unset); 146 assert(mo4.j == Ice.Unset); 147 assert(mo4.k == Ice.Unset); 148 assert(mo4.bs == Ice.Unset); 149 assert(mo4.ss == Ice.Unset); 150 assert(mo4.iid == Ice.Unset); 151 assert(mo4.sid == Ice.Unset); 152 assert(mo4.fs == Ice.Unset); 153 assert(mo4.vs == Ice.Unset); 154 155 assert(mo4.shs == Ice.Unset); 156 assert(mo4.es == Ice.Unset); 157 assert(mo4.fss == Ice.Unset); 158 assert(mo4.vss == Ice.Unset); 159 assert(mo4.oos == Ice.Unset); 160 assert(mo4.oops == Ice.Unset); 161 162 assert(mo4.ied == Ice.Unset); 163 assert(mo4.ifsd == Ice.Unset); 164 assert(mo4.ivsd == Ice.Unset); 165 assert(mo4.iood == Ice.Unset); 166 assert(mo4.ioopd == Ice.Unset); 167 168 assert(mo4.bos == Ice.Unset); 169 170 mo5 = initial.pingPong(mo1); 171 assert(mo5.a == mo1.a); 172 assert(mo5.b == mo1.b); 173 assert(mo5.c == mo1.c); 174 assert(mo5.d == mo1.d); 175 assert(mo5.e == mo1.e); 176 assert(mo5.f == mo1.f); 177 assert(mo5.g == mo1.g); 178 assert(strcmp(mo5.h, mo1.h)); 179 assert(mo5.i == mo1.i); 180 assert(mo5.j == mo1.j); 181 assert(isempty(mo5.k)); 182 assert(mo5.bs(1) == 5); 183 assert(isequal(mo5.ss, mo1.ss)); 184 assert(mo5.iid(4) == 3); 185 assert(mo5.sid('test') == 10); 186 assert(mo5.fs == mo1.fs); 187 assert(mo5.vs == mo1.vs); 188 assert(isequal(mo5.shs, mo1.shs)); 189 assert(mo5.es(1) == MyEnum.MyEnumMember && mo1.es(2) == MyEnum.MyEnumMember); 190 assert(mo5.fss(1) == FixedStruct(78)); 191 assert(mo5.vss(1) == VarStruct('hello')); 192 assert(mo5.oos{1}.a == 15); 193 assert(mo5.oops{1} == communicator.stringToProxy('test')); 194 195 assert(mo5.ied(4) == MyEnum.MyEnumMember); 196 assert(mo5.ifsd(4) == FixedStruct(78)); 197 assert(mo5.ivsd(5) == VarStruct('hello')); 198 assert(mo5.iood(5).a == 15); 199 assert(mo5.ioopd(5) == communicator.stringToProxy('test')); 200 201 assert(isequal(mo5.bos, mo1.bos)); 202 203 % Clear the first half of the optional members 204 mo6 = MultiOptional(); 205 mo6.b = mo5.b; 206 mo6.d = mo5.d; 207 mo6.f = mo5.f; 208 mo6.h = mo5.h; 209 mo6.j = mo5.j; 210 mo6.bs = mo5.bs; 211 mo6.iid = mo5.iid; 212 mo6.fs = mo5.fs; 213 mo6.shs = mo5.shs; 214 mo6.fss = mo5.fss; 215 mo6.oos = mo5.oos; 216 mo6.ifsd = mo5.ifsd; 217 mo6.iood = mo5.iood; 218 mo6.bos = mo5.bos; 219 220 mo7 = initial.pingPong(mo6); 221 assert(mo7.a == Ice.Unset); 222 assert(mo7.b == mo1.b); 223 assert(mo7.c == Ice.Unset); 224 assert(mo7.d == mo1.d); 225 assert(mo7.e == Ice.Unset); 226 assert(mo7.f == mo1.f); 227 assert(mo7.g == Ice.Unset); 228 assert(strcmp(mo7.h, mo1.h)); 229 assert(mo7.i == Ice.Unset); 230 assert(mo7.j == mo1.j); 231 assert(mo7.k == Ice.Unset); 232 assert(mo7.bs(1) == 5); 233 assert(mo7.ss == Ice.Unset); 234 assert(mo7.iid(4) == 3); 235 assert(mo7.sid == Ice.Unset); 236 assert(mo7.fs == mo1.fs); 237 assert(mo7.vs == Ice.Unset); 238 239 assert(isequal(mo7.shs, mo1.shs)); 240 assert(mo7.es == Ice.Unset); 241 assert(mo7.fss(1) == FixedStruct(78)); 242 assert(mo7.vss == Ice.Unset); 243 assert(mo7.oos{1}.a == 15); 244 assert(mo7.oops == Ice.Unset); 245 246 assert(mo7.ied == Ice.Unset); 247 assert(mo7.ifsd(4) == FixedStruct(78)); 248 assert(mo7.ivsd == Ice.Unset); 249 assert(mo7.iood(5).a == 15); 250 assert(mo7.ioopd == Ice.Unset); 251 252 assert(isequal(mo7.bos, [false, true, false])); 253 254 % Clear the second half of the optional members 255 mo8 = MultiOptional(); 256 mo8.a = mo5.a; 257 mo8.c = mo5.c; 258 mo8.e = mo5.e; 259 mo8.g = mo5.g; 260 mo8.i = mo5.i; 261 mo8.k = mo8; 262 mo8.ss = mo5.ss; 263 mo8.sid = mo5.sid; 264 mo8.vs = mo5.vs; 265 266 mo8.es = mo5.es; 267 mo8.vss = mo5.vss; 268 mo8.oops = mo5.oops; 269 270 mo8.ied = mo5.ied; 271 mo8.ivsd = mo5.ivsd; 272 mo8.ioopd = mo5.ioopd; 273 274 mo9 = initial.pingPong(mo8); 275 assert(mo9.a == mo1.a); 276 assert(mo9.b == Ice.Unset); 277 assert(mo9.c == mo1.c); 278 assert(mo9.d == Ice.Unset); 279 assert(mo9.e == mo1.e); 280 assert(mo9.f == Ice.Unset); 281 assert(mo9.g == mo1.g); 282 assert(mo9.h == Ice.Unset); 283 assert(mo9.i == mo1.i); 284 assert(mo9.j == Ice.Unset); 285 assert(mo9.k == mo9); 286 assert(mo9.bs == Ice.Unset); 287 assert(isequal(mo9.ss, mo1.ss)); 288 assert(mo9.iid == Ice.Unset); 289 assert(mo9.sid('test') == 10); 290 assert(mo9.fs == Ice.Unset); 291 assert(mo9.vs == mo1.vs); 292 293 assert(mo9.shs == Ice.Unset); 294 assert(mo9.es(1) == MyEnum.MyEnumMember && mo1.es(2) == MyEnum.MyEnumMember); 295 assert(mo9.fss == Ice.Unset); 296 assert(mo9.vss(1) == VarStruct('hello')); 297 assert(mo9.oos == Ice.Unset); 298 assert(mo9.oops{1} == communicator.stringToProxy('test')); 299 300 assert(mo9.ied(4) == MyEnum.MyEnumMember); 301 assert(mo9.ifsd == Ice.Unset); 302 assert(mo9.ivsd(5) == VarStruct('hello')); 303 assert(mo9.iood == Ice.Unset); 304 assert(mo9.ioopd(5) == communicator.stringToProxy('test')); 305 306 assert(mo9.bos == Ice.Unset); 307 308 % 309 % Use the 1.0 encoding with operations whose only class parameters are optional. 310 % 311 initial.sendOptionalClass(true, OneOptional(53)); 312 initial.ice_encodingVersion(Ice.EncodingVersion(1, 0)).sendOptionalClass(true, OneOptional(53)); 313 314 r = initial.returnOptionalClass(true); 315 assert(r ~= Ice.Unset) 316 r = initial.ice_encodingVersion(Ice.EncodingVersion(1, 0)).returnOptionalClass(true); 317 assert(r == Ice.Unset); 318 319 recursive1 = {}; 320 recursive2 = {}; 321 r1 = Recursive(); 322 r2 = Recursive(); 323 r1.value = recursive2; 324 recursive1{1} = r1; 325 recursive2{1} = r2; 326 327 outer = Recursive(); 328 outer.value = recursive1; 329 initial.pingPong(outer); 330 331 g = G(); 332 g.gg1Opt = G1('gg1Opt'); 333 g.gg2 = G2(10); 334 g.gg2Opt = G2(20); 335 g.gg1 = G1('gg1'); 336 r = initial.opG(g); 337 assert(strcmp(r.gg1Opt.a, 'gg1Opt')); 338 assert(r.gg2.a == 10); 339 assert(r.gg2Opt.a == 20); 340 assert(strcmp(r.gg1.a, 'gg1')); 341 342 initial2 = Initial2Prx.uncheckedCast(base); 343 initial2.opVoid(15, 'test'); 344 345 fprintf('ok\n'); 346 347 fprintf('testing marshaling of large containers with fixed size elements... '); 348 349 mc = MultiOptional(); 350 351 mc.bs = uint8(zeros(1, 1000)); 352 mc.shs = int16(zeros(1, 300)); 353 354 mc.fss = FixedStruct(); 355 for i = 1:300 356 mc.fss(i) = FixedStruct(); 357 end 358 359 mc.ifsd = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 360 for i = 1:300 361 mc.ifsd(i) = FixedStruct(); 362 end 363 364 mc = initial.pingPong(mc); 365 assert(length(mc.bs) == 1000); 366 assert(length(mc.shs) == 300); 367 assert(length(mc.fss) == 300); 368 assert(length(mc.ifsd) == 300); 369 370 fprintf('ok\n'); 371 372 fprintf('testing tag marshaling... '); 373 374 b = B(); 375 b2 = initial.pingPong(b); 376 assert(b2.ma == Ice.Unset); 377 assert(b2.mb == Ice.Unset); 378 assert(b2.mc == Ice.Unset); 379 380 b.ma = 10; 381 b.mb = 11; 382 b.mc = 12; 383 b.md = 13; 384 385 b2 = initial.pingPong(b); 386 assert(b2.ma == 10); 387 assert(b2.mb == 11); 388 assert(b2.mc == 12); 389 assert(b2.md == 13); 390 391 fprintf('ok\n'); 392 393 fprintf('testing marshalling of objects with optional objects... '); 394 395 f = F(); 396 397 f.af = A(); 398 f.ae = f.af; 399 400 rf = initial.pingPong(f); 401 assert(rf.ae == rf.af); 402 403 fprintf('ok\n'); 404 405 fprintf('testing optional with default values... '); 406 407 wd = initial.pingPong(WD()); 408 assert(wd.a == 5); 409 assert(strcmp(wd.s, 'test')); 410 wd.a = Ice.Unset; 411 wd.s = Ice.Unset; 412 wd = initial.pingPong(wd); 413 assert(wd.a == Ice.Unset); 414 assert(wd.s == Ice.Unset); 415 416 fprintf('ok\n'); 417 418 if communicator.getProperties().getPropertyAsInt('Ice.Default.SlicedFormat') > 0 419 fprintf('testing marshaling with unknown class slices... '); 420 421 c = C(); 422 c.ss = 'test'; 423 c.ms = 'testms'; 424 c = initial.pingPong(c); 425 assert(c.ma == Ice.Unset); 426 assert(c.mb == Ice.Unset); 427 assert(c.mc == Ice.Unset); 428 assert(c.md == Ice.Unset); 429 assert(strcmp(c.ss, 'test')); 430 assert(strcmp(c.ms, 'testms')); 431 432 fprintf('ok\n'); 433 434 fprintf('testing optionals with unknown classes... '); 435 436 initial2 = Initial2Prx.uncheckedCast(base); 437 d = D(); 438 d.ds = 'test'; 439 d.seq = {'test1', 'test2', 'test3', 'test4'}; 440 d.ao = A(18, Ice.Unset, Ice.Unset, Ice.Unset); 441 d.requiredB = 14; 442 d.requiredA = 14; 443 initial2.opClassAndUnknownOptional(A(), d); 444 445 fprintf('ok\n'); 446 end 447 448 fprintf('testing optional parameters... '); 449 450 [p2, p3] = initial.opByte(Ice.Unset); 451 assert(p2 == Ice.Unset && p3 == Ice.Unset); 452 [p2, p3] = initial.opByte(56); 453 assert(p2 == 56 && p3 == 56); 454 f = initial.opByteAsync(56); 455 [p2, p3] = f.fetchOutputs(); 456 assert(p2 == 56 && p3 == 56); 457 458 [p2, p3] = initial.opBool(Ice.Unset); 459 assert(p2 == Ice.Unset && p3 == Ice.Unset); 460 [p2, p3] = initial.opBool(true); 461 assert(p2 == true && p3 == true); 462 f = initial.opBoolAsync(true); 463 [p2, p3] = f.fetchOutputs(); 464 assert(p2 == true && p3 == true); 465 466 [p2, p3] = initial.opShort(Ice.Unset); 467 assert(p2 == Ice.Unset && p3 == Ice.Unset); 468 [p2, p3] = initial.opShort(56); 469 assert(p2 == 56 && p3 == 56); 470 f = initial.opShortAsync(56); 471 [p2, p3] = f.fetchOutputs(); 472 assert(p2 == 56 && p3 == 56); 473 474 [p2, p3] = initial.opInt(Ice.Unset); 475 assert(p2 == Ice.Unset && p3 == Ice.Unset); 476 [p2, p3] = initial.opInt(56); 477 assert(p2 == 56 && p3 == 56); 478 f = initial.opIntAsync(56); 479 [p2, p3] = f.fetchOutputs(); 480 assert(p2 == 56 && p3 == 56); 481 482 [p2, p3] = initial.opLong(Ice.Unset); 483 assert(p2 == Ice.Unset && p3 == Ice.Unset); 484 [p2, p3] = initial.opLong(56); 485 assert(p2 == 56 && p3 == 56); 486 f = initial.opLongAsync(56); 487 [p2, p3] = f.fetchOutputs(); 488 assert(p2 == 56 && p3 == 56); 489 490 [p2, p3] = initial.opFloat(Ice.Unset); 491 assert(p2 == Ice.Unset && p3 == Ice.Unset); 492 [p2, p3] = initial.opFloat(1.0); 493 assert(p2 == 1.0 && p3 == 1.0); 494 f = initial.opFloatAsync(1.0); 495 [p2, p3] = f.fetchOutputs(); 496 assert(p2 == 1.0 && p3 == 1.0); 497 498 [p2, p3] = initial.opDouble(Ice.Unset); 499 assert(p2 == Ice.Unset && p3 == Ice.Unset); 500 [p2, p3] = initial.opDouble(1.0); 501 assert(p2 == 1.0 && p3 == 1.0); 502 f = initial.opDoubleAsync(1.0); 503 [p2, p3] = f.fetchOutputs(); 504 assert(p2 == 1.0 && p3 == 1.0); 505 506 [p2, p3] = initial.opString(Ice.Unset); 507 assert(p2 == Ice.Unset && p3 == Ice.Unset); 508 [p2, p3] = initial.opString('test'); 509 assert(strcmp(p2, 'test') && strcmp(p3, 'test')); 510 f = initial.opStringAsync('test'); 511 [p2, p3] = f.fetchOutputs(); 512 assert(strcmp(p2, 'test') && strcmp(p3, 'test')); 513 514 [p2, p3] = initial.opMyEnum(Ice.Unset); 515 assert(p2 == Ice.Unset && p3 == Ice.Unset); 516 [p2, p3] = initial.opMyEnum(MyEnum.MyEnumMember); 517 assert(p2 == MyEnum.MyEnumMember && p3 == MyEnum.MyEnumMember); 518 f = initial.opMyEnumAsync(MyEnum.MyEnumMember); 519 [p2, p3] = f.fetchOutputs(); 520 assert(p2 == MyEnum.MyEnumMember && p3 == MyEnum.MyEnumMember); 521 522 [p2, p3] = initial.opSmallStruct(Ice.Unset); 523 assert(p2 == Ice.Unset && p3 == Ice.Unset); 524 p1 = SmallStruct(56); 525 [p2, p3] = initial.opSmallStruct(p1); 526 assert(p2 == p1 && p3 == p1); 527 [p2, p3] = initial.opSmallStruct([]); % Test null struct 528 assert(p2.m == 0 && p3.m == 0); 529 f = initial.opSmallStructAsync(p1); 530 [p2, p3] = f.fetchOutputs(); 531 assert(p2 == p1 && p3 == p1); 532 533 [p2, p3] = initial.opFixedStruct(Ice.Unset); 534 assert(p2 == Ice.Unset && p3 == Ice.Unset); 535 p1 = FixedStruct(56); 536 [p2, p3] = initial.opFixedStruct(p1); 537 assert(p2 == p1 && p3 == p1); 538 f = initial.opFixedStructAsync(p1); 539 [p2, p3] = f.fetchOutputs(); 540 assert(p2 == p1 && p3 == p1); 541 542 [p2, p3] = initial.opVarStruct(Ice.Unset); 543 assert(p2 == Ice.Unset && p3 == Ice.Unset); 544 p1 = VarStruct('test'); 545 [p2, p3] = initial.opVarStruct(p1); 546 assert(p2 == p1 && p3 == p1); 547 f = initial.opVarStructAsync(p1); 548 [p2, p3] = f.fetchOutputs(); 549 assert(p2 == p1 && p3 == p1); 550 551 [p2, p3] = initial.opOneOptional(Ice.Unset); 552 assert(p2 == Ice.Unset && p3 == Ice.Unset); 553 if initial.supportsNullOptional() 554 [p2, p3] = initial.opOneOptional([]); 555 assert(isempty(p2) && isempty(p3)); 556 end 557 p1 = OneOptional(58); 558 [p2, p3] = initial.opOneOptional(p1); 559 assert(p2.a == p1.a && p3.a == p1.a); 560 f = initial.opOneOptionalAsync(p1); 561 [p2, p3] = f.fetchOutputs(); 562 assert(p2.a == p1.a && p3.a == p1.a); 563 564 [p2, p3] = initial.opOneOptionalProxy(Ice.Unset); 565 assert(p2 == Ice.Unset && p3 == Ice.Unset); 566 p1 = communicator.stringToProxy('test'); 567 [p2, p3] = initial.opOneOptionalProxy(p1); 568 assert(p2 == p1 && p3 == p1); 569 f = initial.opOneOptionalProxyAsync(p1); 570 [p2, p3] = f.fetchOutputs(); 571 assert(p2 == p1 && p3 == p1); 572 573 [p2, p3] = initial.opByteSeq(Ice.Unset); 574 assert(p2 == Ice.Unset && p3 == Ice.Unset); 575 p1 = []; 576 p1(1:100) = 56; 577 [p2, p3] = initial.opByteSeq(p1); 578 assert(length(p2) == length(p1) && length(p3) == length(p1)); 579 assert(p2(1) == 56); 580 assert(p3(1) == 56); 581 f = initial.opByteSeqAsync(p1); 582 [p2, p3] = f.fetchOutputs(); 583 assert(length(p2) == length(p1) && length(p3) == length(p1)); 584 assert(p2(1) == 56); 585 assert(p3(1) == 56); 586 587 [p2, p3] = initial.opBoolSeq(Ice.Unset); 588 assert(p2 == Ice.Unset && p3 == Ice.Unset); 589 p1 = []; 590 p1(1:100) = true; 591 [p2, p3] = initial.opBoolSeq(p1); 592 assert(isequal(p2, p1) && isequal(p3, p1)); 593 f = initial.opBoolSeqAsync(p1); 594 [p2, p3] = f.fetchOutputs(); 595 assert(isequal(p2, p1) && isequal(p3, p1)); 596 597 [p2, p3] = initial.opShortSeq(Ice.Unset); 598 assert(p2 == Ice.Unset && p3 == Ice.Unset); 599 p1 = []; 600 p1(1:100) = 56; 601 [p2, p3] = initial.opShortSeq(p1); 602 assert(isequal(p2, p1) && isequal(p3, p1)); 603 f = initial.opShortSeqAsync(p1); 604 [p2, p3] = f.fetchOutputs(); 605 assert(isequal(p2, p1) && isequal(p3, p1)); 606 607 [p2, p3] = initial.opIntSeq(Ice.Unset); 608 assert(p2 == Ice.Unset && p3 == Ice.Unset); 609 p1 = []; 610 p1(1:100) = 56; 611 [p2, p3] = initial.opIntSeq(p1); 612 assert(isequal(p2, p1) && isequal(p3, p1)); 613 f = initial.opIntSeqAsync(p1); 614 [p2, p3] = f.fetchOutputs(); 615 assert(isequal(p2, p1) && isequal(p3, p1)); 616 617 [p2, p3] = initial.opLongSeq(Ice.Unset); 618 assert(p2 == Ice.Unset && p3 == Ice.Unset); 619 p1 = []; 620 p1(1:100) = 56; 621 [p2, p3] = initial.opLongSeq(p1); 622 assert(isequal(p2, p1) && isequal(p3, p1)); 623 f = initial.opLongSeqAsync(p1); 624 [p2, p3] = f.fetchOutputs(); 625 assert(isequal(p2, p1) && isequal(p3, p1)); 626 627 [p2, p3] = initial.opFloatSeq(Ice.Unset); 628 assert(p2 == Ice.Unset && p3 == Ice.Unset); 629 p1 = []; 630 p1(1:100) = 1.0; 631 [p2, p3] = initial.opFloatSeq(p1); 632 assert(isequal(p2, p1) && isequal(p3, p1)); 633 f = initial.opFloatSeqAsync(p1); 634 [p2, p3] = f.fetchOutputs(); 635 assert(isequal(p2, p1) && isequal(p3, p1)); 636 637 [p2, p3] = initial.opDoubleSeq(Ice.Unset); 638 assert(p2 == Ice.Unset && p3 == Ice.Unset); 639 p1 = []; 640 p1(1:100) = 1.0; 641 [p2, p3] = initial.opDoubleSeq(p1); 642 assert(isequal(p2, p1) && isequal(p3, p1)); 643 f = initial.opDoubleSeqAsync(p1); 644 [p2, p3] = f.fetchOutputs(); 645 assert(isequal(p2, p1) && isequal(p3, p1)); 646 647 [p2, p3] = initial.opStringSeq(Ice.Unset); 648 assert(p2 == Ice.Unset && p3 == Ice.Unset); 649 p1 = cell(1, 100); 650 for i = 1:length(p1) 651 p1{i} = 'test'; 652 end 653 [p2, p3] = initial.opStringSeq(p1); 654 assert(isequal(p2, p1) && isequal(p3, p1)); 655 f = initial.opStringSeqAsync(p1); 656 [p2, p3] = f.fetchOutputs(); 657 assert(isequal(p2, p1) && isequal(p3, p1)); 658 659 [p2, p3] = initial.opSmallStructSeq(Ice.Unset); 660 assert(p2 == Ice.Unset && p3 == Ice.Unset); 661 clear p1; 662 p1(1, 100) = SmallStruct(); 663 for i = 1:length(p1) 664 p1(i) = SmallStruct(1); 665 end 666 [p2, p3] = initial.opSmallStructSeq(p1); 667 assert(isequal(p2, p1) && isequal(p3, p1)); 668 f = initial.opSmallStructSeqAsync(p1); 669 [p2, p3] = f.fetchOutputs(); 670 assert(isequal(p2, p1) && isequal(p3, p1)); 671 672 [p2, p3] = initial.opSmallStructList(Ice.Unset); 673 assert(p2 == Ice.Unset && p3 == Ice.Unset); 674 clear p1; 675 p1(1, 100) = SmallStruct(); 676 for i = 1:length(p1) 677 p1(i) = SmallStruct(1); 678 end 679 [p2, p3] = initial.opSmallStructList(p1); 680 assert(isequal(p2, p1) && isequal(p3, p1)); 681 f = initial.opSmallStructListAsync(p1); 682 [p2, p3] = f.fetchOutputs(); 683 assert(isequal(p2, p1) && isequal(p3, p1)); 684 685 [p2, p3] = initial.opFixedStructSeq(Ice.Unset); 686 assert(p2 == Ice.Unset && p3 == Ice.Unset); 687 clear p1; 688 p1(1, 100) = FixedStruct(); 689 for i = 1:length(p1) 690 p1(i) = FixedStruct(1); 691 end 692 [p2, p3] = initial.opFixedStructSeq(p1); 693 assert(isequal(p2, p1) && isequal(p3, p1)); 694 f = initial.opFixedStructSeqAsync(p1); 695 [p2, p3] = f.fetchOutputs(); 696 assert(isequal(p2, p1) && isequal(p3, p1)); 697 698 [p2, p3] = initial.opFixedStructList(Ice.Unset); 699 assert(p2 == Ice.Unset && p3 == Ice.Unset); 700 clear p1; 701 p1(1, 100) = FixedStruct(); 702 for i = 1:length(p1) 703 p1(i) = FixedStruct(1); 704 end 705 [p2, p3] = initial.opFixedStructList(p1); 706 assert(isequal(p2, p1) && isequal(p3, p1)); 707 f = initial.opFixedStructListAsync(p1); 708 [p2, p3] = f.fetchOutputs(); 709 assert(isequal(p2, p1) && isequal(p3, p1)); 710 711 [p2, p3] = initial.opVarStructSeq(Ice.Unset); 712 assert(p2 == Ice.Unset && p3 == Ice.Unset); 713 clear p1; 714 p1(1, 100) = VarStruct(); 715 for i = 1:length(p1) 716 p1(i) = VarStruct('test'); 717 end 718 [p2, p3] = initial.opVarStructSeq(p1); 719 assert(isequal(p2, p1) && isequal(p3, p1)); 720 f = initial.opVarStructSeqAsync(p1); 721 [p2, p3] = f.fetchOutputs(); 722 assert(isequal(p2, p1) && isequal(p3, p1)); 723 724 [p2, p3] = initial.opIntIntDict(Ice.Unset); 725 assert(p2 == Ice.Unset && p3 == Ice.Unset); 726 p1 = containers.Map('KeyType', 'int32', 'ValueType', 'int32'); 727 p1(1) = 2; 728 p1(2) = 3; 729 [p2, p3] = initial.opIntIntDict(p1); 730 assert(isequal(p2, p1) && isequal(p3, p1)); 731 f = initial.opIntIntDictAsync(p1); 732 [p2, p3] = f.fetchOutputs(); 733 assert(isequal(p2, p1) && isequal(p3, p1)); 734 735 [p2, p3] = initial.opStringIntDict(Ice.Unset); 736 assert(p2 == Ice.Unset && p3 == Ice.Unset); 737 p1 = containers.Map('KeyType', 'char', 'ValueType', 'int32'); 738 p1('1') = 2; 739 p1('2') = 3; 740 [p2, p3] = initial.opStringIntDict(p1); 741 assert(isequal(p2, p1) && isequal(p3, p1)); 742 f = initial.opStringIntDictAsync(p1); 743 [p2, p3] = f.fetchOutputs(); 744 assert(isequal(p2, p1) && isequal(p3, p1)); 745 746 [p2, p3] = initial.opIntOneOptionalDict(Ice.Unset); 747 assert(p2 == Ice.Unset && p3 == Ice.Unset); 748 p1 = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 749 p1(1) = OneOptional(58); 750 p1(2) = OneOptional(59); 751 [p2, p3] = initial.opIntOneOptionalDict(p1); 752 assert(p2(1).a == 58 && p3(1).a == 58); 753 f = initial.opIntOneOptionalDictAsync(p1); 754 [p2, p3] = f.fetchOutputs(); 755 assert(p2(1).a == 58 && p3(1).a == 58); 756 757 fprintf('ok\n'); 758 759 fprintf('testing exception optionals... '); 760 761 try 762 initial.opOptionalException(Ice.Unset, Ice.Unset, Ice.Unset); 763 catch ex 764 assert(isa(ex, 'Test.OptionalException')); 765 assert(ex.a == Ice.Unset); 766 assert(ex.b == Ice.Unset); 767 assert(ex.o == Ice.Unset); 768 end 769 770 try 771 initial.opOptionalException(30, 'test', OneOptional(53)); 772 catch ex 773 assert(isa(ex, 'Test.OptionalException')); 774 assert(ex.a == 30); 775 assert(strcmp(ex.b, 'test')); 776 assert(ex.o.a == 53); 777 end 778 779 try 780 % 781 % Use the 1.0 encoding with an exception whose only class members are optional. 782 % 783 initial.ice_encodingVersion(Ice.EncodingVersion(1, 0)).opOptionalException(30, 'test', OneOptional(53)); 784 catch ex 785 assert(isa(ex, 'Test.OptionalException')); 786 assert(ex.a == Ice.Unset); 787 assert(ex.b == Ice.Unset); 788 assert(ex.o == Ice.Unset); 789 end 790 791 try 792 initial.opDerivedException(Ice.Unset, Ice.Unset, Ice.Unset); 793 catch ex 794 assert(isa(ex, 'Test.DerivedException')); 795 assert(ex.a == Ice.Unset); 796 assert(ex.b == Ice.Unset); 797 assert(ex.o == Ice.Unset); 798 assert(ex.ss == Ice.Unset); 799 assert(ex.o2 == Ice.Unset); 800 end 801 802 try 803 initial.opDerivedException(30, 'test2', OneOptional(53)); 804 catch ex 805 assert(isa(ex, 'Test.DerivedException')); 806 assert(ex.a == 30); 807 assert(strcmp(ex.b, 'test2')); 808 assert(ex.o.a == 53); 809 assert(strcmp(ex.ss, 'test2')); 810 assert(ex.o2 == ex.o); 811 end 812 813 try 814 initial.opRequiredException(Ice.Unset, Ice.Unset, Ice.Unset); 815 catch ex 816 assert(isa(ex, 'Test.RequiredException')); 817 assert(ex.a == Ice.Unset); 818 assert(ex.b == Ice.Unset); 819 assert(ex.o == Ice.Unset); 820 assert(strcmp(ex.ss, 'test')); 821 assert(isempty(ex.o2)); 822 end 823 824 try 825 initial.opRequiredException(30, 'test2', OneOptional(53)); 826 catch ex 827 assert(isa(ex, 'Test.RequiredException')); 828 assert(ex.a == 30); 829 assert(strcmp(ex.b, 'test2')); 830 assert(ex.o.a == 53); 831 assert(strcmp(ex.ss, 'test2')); 832 assert(ex.o2 == ex.o); 833 end 834 835 fprintf('ok\n'); 836 837 r = initial; 838 end 839 end 840end 841