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 = ['test:', helper.getTestEndpoint()]; 13 obj = communicator.stringToProxy(ref); 14 assert(~isempty(obj)); 15 proxy = TestIntfPrx.checkedCast(obj); 16 assert(~isempty(proxy)); 17 18 fprintf('testing enum values... '); 19 20 assert(int32(ByteEnum.benum1) == 0); 21 assert(int32(ByteEnum.benum2) == 1); 22 assert(int32(ByteEnum.benum3) == ByteConst1.value); 23 assert(int32(ByteEnum.benum4) == ByteConst1.value + 1); 24 assert(int32(ByteEnum.benum5) == ShortConst1.value); 25 assert(int32(ByteEnum.benum6) == ShortConst1.value + 1); 26 assert(int32(ByteEnum.benum7) == IntConst1.value); 27 assert(int32(ByteEnum.benum8) == IntConst1.value + 1); 28 assert(int32(ByteEnum.benum9) == LongConst1.value); 29 assert(int32(ByteEnum.benum10) == LongConst1.value + 1); 30 assert(int32(ByteEnum.benum11) == ByteConst2.value); 31 32 assert(ByteEnum.ice_getValue(0) == ByteEnum.benum1); 33 assert(ByteEnum.ice_getValue(1) == ByteEnum.benum2); 34 assert(ByteEnum.ice_getValue(ByteConst1.value) == ByteEnum.benum3); 35 assert(ByteEnum.ice_getValue(ByteConst1.value + 1) == ByteEnum.benum4); 36 assert(ByteEnum.ice_getValue(ShortConst1.value) == ByteEnum.benum5); 37 assert(ByteEnum.ice_getValue(ShortConst1.value + 1) == ByteEnum.benum6); 38 assert(ByteEnum.ice_getValue(IntConst1.value) == ByteEnum.benum7); 39 assert(ByteEnum.ice_getValue(IntConst1.value + 1) == ByteEnum.benum8); 40 assert(ByteEnum.ice_getValue(LongConst1.value) == ByteEnum.benum9); 41 assert(ByteEnum.ice_getValue(LongConst1.value + 1) == ByteEnum.benum10); 42 assert(ByteEnum.ice_getValue(ByteConst2.value) == ByteEnum.benum11); 43 44 assert(int32(ShortEnum.senum1) == 3); 45 assert(int32(ShortEnum.senum2) == 4); 46 assert(int32(ShortEnum.senum3) == ByteConst1.value); 47 assert(int32(ShortEnum.senum4) == ByteConst1.value + 1); 48 assert(int32(ShortEnum.senum5) == ShortConst1.value); 49 assert(int32(ShortEnum.senum6) == ShortConst1.value + 1); 50 assert(int32(ShortEnum.senum7) == IntConst1.value); 51 assert(int32(ShortEnum.senum8) == IntConst1.value + 1); 52 assert(int32(ShortEnum.senum9) == LongConst1.value); 53 assert(int32(ShortEnum.senum10) == LongConst1.value + 1); 54 assert(int32(ShortEnum.senum11) == ShortConst2.value); 55 56 assert(ShortEnum.ice_getValue(3) == ShortEnum.senum1); 57 assert(ShortEnum.ice_getValue(4) == ShortEnum.senum2); 58 assert(ShortEnum.ice_getValue(ByteConst1.value) == ShortEnum.senum3); 59 assert(ShortEnum.ice_getValue(ByteConst1.value + 1) == ShortEnum.senum4); 60 assert(ShortEnum.ice_getValue(ShortConst1.value) == ShortEnum.senum5); 61 assert(ShortEnum.ice_getValue(ShortConst1.value + 1) == ShortEnum.senum6); 62 assert(ShortEnum.ice_getValue(IntConst1.value) == ShortEnum.senum7); 63 assert(ShortEnum.ice_getValue(IntConst1.value + 1) == ShortEnum.senum8); 64 assert(ShortEnum.ice_getValue(LongConst1.value) == ShortEnum.senum9); 65 assert(ShortEnum.ice_getValue(LongConst1.value + 1) == ShortEnum.senum10); 66 assert(ShortEnum.ice_getValue(ShortConst2.value) == ShortEnum.senum11); 67 68 assert(int32(IntEnum.ienum1) == 0); 69 assert(int32(IntEnum.ienum2) == 1); 70 assert(int32(IntEnum.ienum3) == ByteConst1.value); 71 assert(int32(IntEnum.ienum4) == ByteConst1.value + 1); 72 assert(int32(IntEnum.ienum5) == ShortConst1.value); 73 assert(int32(IntEnum.ienum6) == ShortConst1.value + 1); 74 assert(int32(IntEnum.ienum7) == IntConst1.value); 75 assert(int32(IntEnum.ienum8) == IntConst1.value + 1); 76 assert(int32(IntEnum.ienum9) == LongConst1.value); 77 assert(int32(IntEnum.ienum10) == LongConst1.value + 1); 78 assert(int32(IntEnum.ienum11) == IntConst2.value); 79 assert(int32(IntEnum.ienum12) == LongConst2.value); 80 81 assert(IntEnum.ice_getValue(0) == IntEnum.ienum1); 82 assert(IntEnum.ice_getValue(1) == IntEnum.ienum2); 83 assert(IntEnum.ice_getValue(ByteConst1.value) == IntEnum.ienum3); 84 assert(IntEnum.ice_getValue(ByteConst1.value + 1) == IntEnum.ienum4); 85 assert(IntEnum.ice_getValue(ShortConst1.value) == IntEnum.ienum5); 86 assert(IntEnum.ice_getValue(ShortConst1.value + 1) == IntEnum.ienum6); 87 assert(IntEnum.ice_getValue(IntConst1.value) == IntEnum.ienum7); 88 assert(IntEnum.ice_getValue(IntConst1.value + 1) == IntEnum.ienum8); 89 assert(IntEnum.ice_getValue(LongConst1.value) == IntEnum.ienum9); 90 assert(IntEnum.ice_getValue(LongConst1.value + 1) == IntEnum.ienum10); 91 assert(IntEnum.ice_getValue(IntConst2.value) == IntEnum.ienum11); 92 assert(IntEnum.ice_getValue(LongConst2.value) == IntEnum.ienum12); 93 94 assert(int32(SimpleEnum.red) == 0); 95 assert(int32(SimpleEnum.green) == 1); 96 assert(int32(SimpleEnum.blue) == 2); 97 98 assert(SimpleEnum.ice_getValue(0) == SimpleEnum.red); 99 assert(SimpleEnum.ice_getValue(1) == SimpleEnum.green); 100 assert(SimpleEnum.ice_getValue(2) == SimpleEnum.blue); 101 102 fprintf('ok\n'); 103 104 fprintf('testing enum streaming... '); 105 106 encoding_1_0 = strcmp(communicator.getProperties().getProperty('Ice.Default.EncodingVersion'), '1.0'); 107 108 os = communicator.createOutputStream(); 109 ByteEnum.ice_write(os, ByteEnum.benum11); 110 bytes = os.finished(); 111 assert(length(bytes) == 1); % ByteEnum should require one byte 112 113 os = communicator.createOutputStream(); 114 ShortEnum.ice_write(os, ShortEnum.senum11); 115 bytes = os.finished(); 116 if encoding_1_0 117 assert(length(bytes) == 2); 118 else 119 assert(length(bytes) == 5); 120 end 121 122 os = communicator.createOutputStream(); 123 IntEnum.ice_write(os, IntEnum.ienum11); 124 bytes = os.finished(); 125 if encoding_1_0 126 assert(length(bytes) == 4); 127 else 128 assert(length(bytes) == 5); 129 end 130 131 os = communicator.createOutputStream(); 132 SimpleEnum.ice_write(os, SimpleEnum.blue); 133 bytes = os.finished(); 134 assert(length(bytes) == 1); % SimpleEnum should require one byte 135 136 fprintf('ok\n'); 137 138 fprintf('testing enum operations... '); 139 140 [r, b2] = proxy.opByte(ByteEnum.benum1); 141 assert(r == ByteEnum.benum1 && b2 == ByteEnum.benum1); 142 [r, b2] = proxy.opByte(ByteEnum.benum11); 143 assert(r == ByteEnum.benum11 && b2 == ByteEnum.benum11); 144 145 [r, s2] = proxy.opShort(ShortEnum.senum1); 146 assert(r == ShortEnum.senum1 && r == ShortEnum.senum1); 147 [r, s2] = proxy.opShort(ShortEnum.senum11); 148 assert(r == ShortEnum.senum11 && r == ShortEnum.senum11); 149 150 [r, i2] = proxy.opInt(IntEnum.ienum1); 151 assert(r == IntEnum.ienum1 && i2 == IntEnum.ienum1); 152 [r, i2] = proxy.opInt(IntEnum.ienum11); 153 assert(r == IntEnum.ienum11 && i2 == IntEnum.ienum11); 154 [r, i2] = proxy.opInt(IntEnum.ienum12); 155 assert(r == IntEnum.ienum12 && i2 == IntEnum.ienum12); 156 157 [r, s2] = proxy.opSimple(SimpleEnum.green); 158 assert(r == SimpleEnum.green && s2 == SimpleEnum.green); 159 160 fprintf('ok\n'); 161 162 fprintf('testing enum sequences operations... '); 163 164 b1 = [ ByteEnum.benum1, ByteEnum.benum2, ByteEnum.benum3, ByteEnum.benum4, ByteEnum.benum5, ... 165 ByteEnum.benum6, ByteEnum.benum7, ByteEnum.benum8, ByteEnum.benum9, ByteEnum.benum10, ... 166 ByteEnum.benum11 ]; 167 168 [r, b2] = proxy.opByteSeq(b1); 169 170 for i = 1:length(b1) 171 assert(b1(i) == b2(i)); 172 assert(b1(i) == r(i)); 173 end 174 175 s1 = [ ShortEnum.senum1, ShortEnum.senum2, ShortEnum.senum3, ShortEnum.senum4, ShortEnum.senum5, ... 176 ShortEnum.senum6, ShortEnum.senum7, ShortEnum.senum8, ShortEnum.senum9, ShortEnum.senum10, ... 177 ShortEnum.senum11 ]; 178 179 [r, s2] = proxy.opShortSeq(s1); 180 181 for i = 1:length(s1) 182 assert(s1(i) == s2(i)); 183 assert(s1(i) == r(i)); 184 end 185 186 i1 = [ IntEnum.ienum1, IntEnum.ienum2, IntEnum.ienum3, IntEnum.ienum4, IntEnum.ienum5, ... 187 IntEnum.ienum6, IntEnum.ienum7, IntEnum.ienum8, IntEnum.ienum9, IntEnum.ienum10, ... 188 IntEnum.ienum11 ]; 189 190 [r, i2] = proxy.opIntSeq(i1); 191 192 for i = 1:length(i1) 193 assert(i1(i) == i2(i)); 194 assert(i1(i) == r(i)); 195 end 196 197 s1 = [ SimpleEnum.red, SimpleEnum.green, SimpleEnum.blue ]; 198 199 [r, s2] = proxy.opSimpleSeq(s1); 200 201 for i = 1:length(s1) 202 assert(s1(i) == s2(i)); 203 assert(s1(i) == r(i)); 204 end 205 206 fprintf('ok\n'); 207 208 fprintf('testing enum exceptions... '); 209 210 try 211 os = communicator.createOutputStream(); 212 os.writeByte(2); % Invalid enumerator 213 in = os.createInputStream(); 214 ByteEnum.ice_read(in); 215 assert(false); 216 catch ex 217 assert(isa(ex, 'Ice.MarshalException')); 218 end 219 220 try 221 os = communicator.createOutputStream(); 222 os.writeByte(128); % Invalid enumerator 223 in = os.createInputStream(); 224 ByteEnum.ice_read(in); 225 assert(false); 226 catch ex 227 assert(isa(ex, 'Ice.MarshalException')); 228 end 229 230 try 231 os = communicator.createOutputStream(); 232 os.writeShort(-1); % Negative enumerators are not supported 233 in = os.createInputStream(); 234 ShortEnum.ice_read(in); 235 assert(false); 236 catch ex 237 assert(isa(ex, 'Ice.MarshalException')); 238 end 239 240 try 241 os = communicator.createOutputStream(); 242 os.writeShort(0); % Invalid enumerator 243 in = os.createInputStream(); 244 ShortEnum.ice_read(in); 245 assert(false); 246 catch ex 247 assert(isa(ex, 'Ice.MarshalException')); 248 end 249 250 try 251 os = communicator.createOutputStream(); 252 os.writeShort(32767); % Invalid enumerator 253 in = os.createInputStream(); 254 ShortEnum.ice_read(in); 255 assert(false); 256 catch ex 257 assert(isa(ex, 'Ice.MarshalException')); 258 end 259 260 try 261 os = communicator.createOutputStream(); 262 os.writeInt(-1); % Negative enumerators are not supported 263 in = os.createInputStream(); 264 IntEnum.ice_read(in); 265 assert(false); 266 catch ex 267 assert(isa(ex, 'Ice.MarshalException')); 268 end 269 270 try 271 os = communicator.createOutputStream(); 272 os.writeInt(2); % Invalid enumerator 273 in = os.createInputStream(); 274 IntEnum.ice_read(in); 275 assert(false); 276 catch ex 277 assert(isa(ex, 'Ice.MarshalException')); 278 end 279 280 fprintf('ok\n'); 281 282 r = proxy; 283 end 284 end 285end 286