/packages/fcl-sdo/tests/test_suite/test_property.pas

https://github.com/slibre/freepascal · Pascal · 1035 lines · 868 code · 84 blank · 83 comment · 6 complexity · be11e375bdc69502854b600a999b6e75 MD5 · raw file

  1. {$INCLUDE sdo_global.inc}
  2. unit test_property;
  3. interface
  4. uses SysUtils
  5. {$IFDEF FPC}
  6. ,fpcunit, testutils, testregistry
  7. {$ENDIF}
  8. {$IFNDEF FPC}
  9. ,TestFrameWork
  10. {$ENDIF}
  11. ,test_suite_utils, sdo, sdo_type, sdo_types, sdo_property ;
  12. type
  13. TSDOPropertyAsbtract_Test = class(TWstBaseTest)
  14. protected
  15. class function create_obj(
  16. const AName : string;
  17. const AType : ISDOType;
  18. const AMany : Boolean;
  19. const AContained : Boolean;
  20. const AContainingType : ISDOType;
  21. const AReadOnly : Boolean;
  22. const AIsAttribute : Boolean
  23. ) : ISDOProperty;virtual;abstract;
  24. public
  25. procedure CheckEquals(expected, actual: TSDODate; msg: string = ''; const AStrict : Boolean = True); overload;
  26. published
  27. procedure test_create();
  28. procedure setDefault_boolean();
  29. procedure setDefault_byte();
  30. procedure setDefault_integer();
  31. procedure setDefault_string();
  32. procedure setDefault_object();
  33. procedure setDefault_date();
  34. {$IFDEF HAS_SDO_BYTES}
  35. procedure setDefault_bytes();
  36. {$ENDIF HAS_SDO_BYTES}
  37. {$IFDEF HAS_SDO_CHAR}
  38. procedure setDefault_char();
  39. {$ENDIF HAS_SDO_CHAR}
  40. {$IFDEF HAS_SDO_CURRENCY}
  41. procedure setDefault_currency();
  42. {$ENDIF HAS_SDO_CURRENCY}
  43. {$IFDEF HAS_SDO_DOUBLE}
  44. procedure setDefault_double();
  45. {$ENDIF HAS_SDO_DOUBLE}
  46. {$IFDEF HAS_SDO_FLOAT}
  47. procedure setDefault_float();
  48. {$ENDIF HAS_SDO_FLOAT}
  49. {$IFDEF HAS_SDO_LONG}
  50. procedure setDefault_long();
  51. {$ENDIF HAS_SDO_LONG}
  52. {$IFDEF HAS_SDO_SHORT}
  53. procedure setDefault_short();
  54. {$ENDIF HAS_SDO_SHORT}
  55. end;
  56. TSDOProperty_Test = class(TSDOPropertyAsbtract_Test)
  57. protected
  58. class function create_obj(
  59. const AName : string;
  60. const AType : ISDOType;
  61. const AMany : Boolean;
  62. const AContained : Boolean;
  63. const AContainingType : ISDOType;
  64. const AReadOnly : Boolean;
  65. const AIsAttribute : Boolean
  66. ) : ISDOProperty;override;
  67. end;
  68. implementation
  69. uses sdo_datafactory, Math, DateUtils, sdo_date_utils;
  70. const
  71. s_uri = 'test-uri';
  72. s_type_object_A = 'Object_A'; s_type_object_B = 'Object_B';
  73. { TSDOPropertyAsbtract_Test }
  74. procedure TSDOPropertyAsbtract_Test.CheckEquals(expected, actual: TSDODate;
  75. msg: string; const AStrict: Boolean
  76. );
  77. var
  78. e, a : TDateTime;
  79. e_y, e_m, e_d, e_h, e_mn, e_ss, e_ms : Word;
  80. a_y, a_m, a_d, a_h, a_mn, a_ss, a_ms : Word;
  81. begin
  82. if AStrict then begin
  83. Check(CompareMem(@expected, @actual, SizeOf(TSDODate)), msg);
  84. end else begin
  85. e := NormalizeToUTC(expected);
  86. a := NormalizeToUTC(actual);
  87. DecodeDateTime(e, e_y, e_m, e_d, e_h, e_mn, e_ss, e_ms);
  88. DecodeDateTime(a, a_y, a_m, a_d, a_h, a_mn, a_ss, a_ms);
  89. CheckEquals(e_y,a_y,msg);
  90. CheckEquals(e_m,a_m,msg);
  91. CheckEquals(e_d,a_d,msg);
  92. CheckEquals(e_h,a_h,msg);
  93. CheckEquals(e_mn,a_mn,msg);
  94. CheckEquals(e_ss,a_ss,msg);
  95. CheckEquals(e_ms,a_ms,msg);
  96. end;
  97. end;
  98. procedure TSDOPropertyAsbtract_Test.setDefault_boolean();
  99. var
  100. locFac : ISDODataFactory;
  101. locObj : ISDOProperty;
  102. tmpVal : TSDOBoolean;
  103. ok : Boolean;
  104. begin
  105. Randomize();
  106. locFac := TSDODataFactory.Create() as ISDODataFactory;
  107. locFac.AddType(s_uri,s_type_object_A,[]);
  108. locFac.AddType(s_uri,s_type_object_B,[]);
  109. locObj := create_obj(
  110. (*Name*) 'p_bool',
  111. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[BooleanType]),
  112. (* Many *) False,
  113. (*Contained*) False,
  114. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  115. (*ReadOnly*) False,
  116. (*Attribute*) True
  117. );
  118. CheckEquals(False, locObj.isDefaulted());
  119. CheckEquals(False, locObj.getBooleanDefault());
  120. CheckEquals(0, locObj.getIntegerDefault());
  121. CheckEquals('', locObj.getStringDefault());
  122. tmpVal := False;
  123. locObj.setDefault(tmpVal);
  124. CheckEquals(True, locObj.isDefaulted());
  125. CheckEquals(tmpVal, locObj.getBooleanDefault());
  126. tmpVal := True;
  127. locObj.setDefault(tmpVal);
  128. CheckEquals(True, locObj.isDefaulted());
  129. CheckEquals(tmpVal, locObj.getBooleanDefault());
  130. locFac.createNew(s_uri,s_type_object_A);
  131. ok := False;
  132. try
  133. locObj.setDefault(False);
  134. except
  135. on e : ESDOUnsupportedOperationException do
  136. ok := True;
  137. end;
  138. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  139. end;
  140. procedure TSDOPropertyAsbtract_Test.setDefault_byte();
  141. const
  142. PROP_TYPE = ByteType;
  143. var
  144. locFac : ISDODataFactory;
  145. locObj : ISDOProperty;
  146. tmpVal : TSDOByte;
  147. ok : Boolean;
  148. begin
  149. Randomize();
  150. locFac := TSDODataFactory.Create() as ISDODataFactory;
  151. locFac.AddType(s_uri,s_type_object_A,[]);
  152. locFac.AddType(s_uri,s_type_object_B,[]);
  153. locObj := create_obj(
  154. (*Name*) 'p_sample',
  155. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  156. (* Many *) False,
  157. (*Contained*) False,
  158. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  159. (*ReadOnly*) False,
  160. (*Attribute*) True
  161. );
  162. CheckEquals(False, locObj.isDefaulted());
  163. CheckEquals(False, locObj.getBooleanDefault());
  164. CheckEquals(0, locObj.getByteDefault());
  165. CheckEquals(0, locObj.getIntegerDefault());
  166. CheckEquals('', locObj.getStringDefault());
  167. tmpVal := RandomRange(Low(TSDOByte),High(TSDOByte));
  168. locObj.setDefault(tmpVal);
  169. CheckEquals(True, locObj.isDefaulted());
  170. CheckEquals(tmpVal, locObj.getByteDefault());
  171. tmpVal := RandomRange(Low(TSDOByte),High(TSDOByte));
  172. locObj.setDefault(tmpVal);
  173. CheckEquals(True, locObj.isDefaulted());
  174. CheckEquals(tmpVal, locObj.getByteDefault());
  175. locFac.createNew(s_uri,s_type_object_A);
  176. ok := False;
  177. try
  178. locObj.setDefault(TSDOByte(123));
  179. except
  180. on e : ESDOUnsupportedOperationException do
  181. ok := True;
  182. end;
  183. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  184. end;
  185. procedure TSDOPropertyAsbtract_Test.setDefault_date();
  186. var
  187. locFac : ISDODataFactory;
  188. locObj : ISDOProperty;
  189. tmpVal : TSDODate;
  190. ok : Boolean;
  191. begin
  192. Randomize();
  193. locFac := TSDODataFactory.Create() as ISDODataFactory;
  194. locFac.AddType(s_uri,s_type_object_A,[]);
  195. locFac.AddType(s_uri,s_type_object_B,[]);
  196. locObj := create_obj(
  197. (*Name*) 'p_dt',
  198. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[DateTimeType]),
  199. (* Many *) False,
  200. (*Contained*) False,
  201. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  202. (*ReadOnly*) False,
  203. (*Attribute*) True
  204. );
  205. CheckEquals(False, locObj.isDefaulted());
  206. CheckEquals(False, locObj.getBooleanDefault());
  207. CheckEquals(0, locObj.getByteDefault());
  208. CheckEquals(0, locObj.getIntegerDefault());
  209. CheckEquals('', locObj.getStringDefault());
  210. CheckEquals(ZERO_DATE,locObj.getDateDefault());
  211. tmpVal := xsd_StrToDate('1976-10-12T23:34:56.7',xdkDateTime);
  212. locObj.setDefault(tmpVal);
  213. CheckEquals(True, locObj.isDefaulted());
  214. CheckEquals(tmpVal, locObj.getDateDefault());
  215. tmpVal := xsd_StrToDate('1987-11-12',xdkDateTime);
  216. locObj.setDefault(tmpVal);
  217. CheckEquals(True, locObj.isDefaulted());
  218. CheckEquals(tmpVal, locObj.getDateDefault());
  219. locFac.createNew(s_uri,s_type_object_A);
  220. ok := False;
  221. try
  222. locObj.setDefault(xsd_StrToDate('1987-11-12',xdkDateTime));
  223. except
  224. on e : ESDOUnsupportedOperationException do
  225. ok := True;
  226. end;
  227. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  228. end;
  229. procedure TSDOPropertyAsbtract_Test.setDefault_integer();
  230. var
  231. locFac : ISDODataFactory;
  232. locObj : ISDOProperty;
  233. tmpVal : TSDOInteger;
  234. ok : Boolean;
  235. begin
  236. Randomize();
  237. locFac := TSDODataFactory.Create() as ISDODataFactory;
  238. locFac.AddType(s_uri,s_type_object_A,[]);
  239. locFac.AddType(s_uri,s_type_object_B,[]);
  240. locObj := create_obj(
  241. (*Name*) 'p_int',
  242. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[IntegerType]),
  243. (* Many *) False,
  244. (*Contained*) False,
  245. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  246. (*ReadOnly*) False,
  247. (*Attribute*) True
  248. );
  249. CheckEquals(False, locObj.isDefaulted());
  250. CheckEquals(False, locObj.getBooleanDefault());
  251. CheckEquals(0, locObj.getIntegerDefault());
  252. CheckEquals('', locObj.getStringDefault());
  253. tmpVal := RandomRange(-12345,12345);
  254. locObj.setDefault(tmpVal);
  255. CheckEquals(True, locObj.isDefaulted());
  256. CheckEquals(tmpVal, locObj.getIntegerDefault());
  257. tmpVal := RandomRange(-12345,12345);
  258. locObj.setDefault(tmpVal);
  259. CheckEquals(True, locObj.isDefaulted());
  260. CheckEquals(tmpVal, locObj.getIntegerDefault());
  261. locFac.createNew(s_uri,s_type_object_A);
  262. ok := False;
  263. try
  264. locObj.setDefault(123);
  265. except
  266. on e : ESDOUnsupportedOperationException do
  267. ok := True;
  268. end;
  269. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  270. end;
  271. {$IFDEF HAS_SDO_BYTES}
  272. procedure TSDOPropertyAsbtract_Test.setDefault_bytes();
  273. const
  274. PROP_TYPE = BytesType;
  275. var
  276. locFac : ISDODataFactory;
  277. locObj : ISDOProperty;
  278. tmpVal : TSDOBytes;
  279. ok : Boolean;
  280. begin
  281. Randomize();
  282. locFac := TSDODataFactory.Create() as ISDODataFactory;
  283. locFac.AddType(s_uri,s_type_object_A,[]);
  284. locFac.AddType(s_uri,s_type_object_B,[]);
  285. locObj := create_obj(
  286. (*Name*) 'p_sample',
  287. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  288. (* Many *) False,
  289. (*Contained*) False,
  290. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  291. (*ReadOnly*) False,
  292. (*Attribute*) True
  293. );
  294. CheckEquals(False, locObj.isDefaulted());
  295. CheckEquals(False, locObj.getBooleanDefault());
  296. CheckEquals(TSDOBytes(nil), locObj.getBytesDefault());
  297. CheckEquals('', locObj.getStringDefault());
  298. tmpVal := RandomBytes(100);
  299. locObj.setDefault(tmpVal);
  300. CheckEquals(True, locObj.isDefaulted());
  301. CheckEquals(tmpVal, locObj.getBytesDefault());
  302. CheckEquals(BytesToString(tmpVal), locObj.getStringDefault());
  303. tmpVal := RandomBytes(100);
  304. locObj.setDefault(tmpVal);
  305. CheckEquals(True, locObj.isDefaulted());
  306. CheckEquals(tmpVal, locObj.getBytesDefault());
  307. CheckEquals(BytesToString(tmpVal), locObj.getStringDefault());
  308. locFac.createNew(s_uri,s_type_object_A);
  309. ok := False;
  310. try
  311. locObj.setDefault(RandomBytes(100));
  312. except
  313. on e : ESDOUnsupportedOperationException do
  314. ok := True;
  315. end;
  316. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  317. end;
  318. {$ENDIF HAS_SDO_BYTES}
  319. {$IFDEF HAS_SDO_CHAR}
  320. procedure TSDOPropertyAsbtract_Test.setDefault_char();
  321. const
  322. PROP_TYPE = CharacterType;
  323. var
  324. locFac : ISDODataFactory;
  325. locObj : ISDOProperty;
  326. tmpVal : TSDOChar;
  327. ok : Boolean;
  328. begin
  329. Randomize();
  330. locFac := TSDODataFactory.Create() as ISDODataFactory;
  331. locFac.AddType(s_uri,s_type_object_A,[]);
  332. locFac.AddType(s_uri,s_type_object_B,[]);
  333. locObj := create_obj(
  334. (*Name*) 'p_sample',
  335. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  336. (* Many *) False,
  337. (*Contained*) False,
  338. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  339. (*ReadOnly*) False,
  340. (*Attribute*) True
  341. );
  342. CheckEquals(False, locObj.isDefaulted());
  343. CheckEquals(False, locObj.getBooleanDefault());
  344. CheckEquals(0, locObj.getByteDefault());
  345. {$IFDEF HAS_SDO_CHAR}
  346. CheckEquals(#0, locObj.getCharacterDefault());
  347. {$ENDIF HAS_SDO_CHAR}
  348. CheckEquals(0, locObj.getIntegerDefault());
  349. {$IFDEF HAS_SDO_LONG}
  350. CheckEquals(0, locObj.getLongDefault());
  351. {$ENDIF HAS_SDO_LONG}
  352. {$IFDEF HAS_SDO_SHORT}
  353. CheckEquals(0, locObj.getShortDefault());
  354. {$ENDIF HAS_SDO_SHORT}
  355. CheckEquals('', locObj.getStringDefault());
  356. tmpVal := TSDOChar(RandomRange(Ord(Low(TSDOChar)),Ord(High(TSDOChar))));
  357. locObj.setDefault(tmpVal);
  358. CheckEquals(True, locObj.isDefaulted());
  359. CheckEquals(tmpVal, locObj.getCharacterDefault());
  360. tmpVal := TSDOChar(RandomRange(Ord(Low(TSDOChar)),Ord(High(TSDOChar))));
  361. locObj.setDefault(tmpVal);
  362. CheckEquals(True, locObj.isDefaulted());
  363. CheckEquals(tmpVal, locObj.getCharacterDefault());
  364. locFac.createNew(s_uri,s_type_object_A);
  365. ok := False;
  366. try
  367. locObj.setDefault(TSDOChar('s'));
  368. except
  369. on e : ESDOUnsupportedOperationException do
  370. ok := True;
  371. end;
  372. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  373. end;
  374. {$ENDIF HAS_SDO_CHAR}
  375. {$IFDEF HAS_SDO_CURRENCY}
  376. procedure TSDOPropertyAsbtract_Test.setDefault_currency();
  377. const
  378. PROP_TYPE = CurrencyType;
  379. VAL_1 : TSDOCurrency = 1238653223453;
  380. var
  381. locFac : ISDODataFactory;
  382. locObj : ISDOProperty;
  383. tmpVal : TSDOCurrency;
  384. ok : Boolean;
  385. begin
  386. Randomize();
  387. locFac := TSDODataFactory.Create() as ISDODataFactory;
  388. locFac.AddType(s_uri,s_type_object_A,[]);
  389. locFac.AddType(s_uri,s_type_object_B,[]);
  390. locObj := create_obj(
  391. (*Name*) 'p_sample',
  392. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  393. (* Many *) False,
  394. (*Contained*) False,
  395. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  396. (*ReadOnly*) False,
  397. (*Attribute*) True
  398. );
  399. CheckEquals(False, locObj.isDefaulted());
  400. CheckEquals(False, locObj.getBooleanDefault());
  401. CheckEquals(0, locObj.getByteDefault());
  402. {$IFDEF HAS_SDO_CHAR}
  403. CheckEquals(#0, locObj.getCharacterDefault());
  404. {$ENDIF HAS_SDO_CHAR}
  405. {$IFDEF HAS_SDO_DOUBLE}
  406. CheckEquals(0, locObj.getDoubleDefault());
  407. {$ENDIF HAS_SDO_DOUBLE}
  408. {$IFDEF HAS_SDO_FLOAT}
  409. CheckEquals(0, locObj.getFloatDefault());
  410. {$ENDIF HAS_SDO_FLOAT}
  411. {$IFDEF HAS_SDO_LONG}
  412. CheckEquals(0, locObj.getLongDefault());
  413. {$ENDIF HAS_SDO_LONG}
  414. {$IFDEF HAS_SDO_SHORT}
  415. CheckEquals(0, locObj.getShortDefault());
  416. {$ENDIF HAS_SDO_SHORT}
  417. CheckEquals(0, locObj.getIntegerDefault());
  418. CheckEquals('', locObj.getStringDefault());
  419. CheckEquals(0, locObj.getCurrencyDefault());
  420. tmpVal := test_suite_utils.RandomRange(Low(Word),High(Word));
  421. locObj.setDefaultCurrency(tmpVal);
  422. CheckEquals(True, locObj.isDefaulted());
  423. CheckEquals(tmpVal, locObj.getCurrencyDefault());
  424. tmpVal := test_suite_utils.RandomRange(Low(Word),High(Word));
  425. locObj.setDefaultCurrency(tmpVal);
  426. CheckEquals(True, locObj.isDefaulted());
  427. CheckEquals(tmpVal, locObj.getCurrencyDefault());
  428. locFac.createNew(s_uri,s_type_object_A);
  429. ok := False;
  430. try
  431. locObj.setDefaultCurrency(VAL_1);
  432. except
  433. on e : ESDOUnsupportedOperationException do
  434. ok := True;
  435. end;
  436. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  437. end;
  438. {$ENDIF HAS_SDO_CURRENCY}
  439. {$IFDEF HAS_SDO_DOUBLE}
  440. procedure TSDOPropertyAsbtract_Test.setDefault_double();
  441. const
  442. PROP_TYPE = DoubleType;
  443. VAL_1 : TSDODouble = 1238653223453;
  444. var
  445. locFac : ISDODataFactory;
  446. locObj : ISDOProperty;
  447. tmpVal : TSDODouble;
  448. ok : Boolean;
  449. begin
  450. Randomize();
  451. locFac := TSDODataFactory.Create() as ISDODataFactory;
  452. locFac.AddType(s_uri,s_type_object_A,[]);
  453. locFac.AddType(s_uri,s_type_object_B,[]);
  454. locObj := create_obj(
  455. (*Name*) 'p_sample',
  456. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  457. (* Many *) False,
  458. (*Contained*) False,
  459. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  460. (*ReadOnly*) False,
  461. (*Attribute*) True
  462. );
  463. CheckEquals(False, locObj.isDefaulted());
  464. CheckEquals(False, locObj.getBooleanDefault());
  465. CheckEquals(0, locObj.getByteDefault());
  466. {$IFDEF HAS_SDO_CHAR}
  467. CheckEquals(#0, locObj.getCharacterDefault());
  468. {$ENDIF HAS_SDO_CHAR}
  469. {$IFDEF HAS_SDO_CURRENCY}
  470. CheckEquals(0, locObj.getCurrencyDefault());
  471. {$ENDIF HAS_SDO_CURRENCY}
  472. {$IFDEF HAS_SDO_FLOAT}
  473. CheckEquals(0, locObj.getFloatDefault());
  474. {$ENDIF HAS_SDO_FLOAT}
  475. {$IFDEF HAS_SDO_LONG}
  476. CheckEquals(0, locObj.getLongDefault());
  477. {$ENDIF HAS_SDO_LONG}
  478. {$IFDEF HAS_SDO_SHORT}
  479. CheckEquals(0, locObj.getShortDefault());
  480. {$ENDIF HAS_SDO_SHORT}
  481. CheckEquals(0, locObj.getIntegerDefault());
  482. CheckEquals('', locObj.getStringDefault());
  483. CheckEquals(0, locObj.getDoubleDefault());
  484. tmpVal := test_suite_utils.RandomRange(Low(Word),High(Word));
  485. locObj.setDefault(tmpVal);
  486. CheckEquals(True, locObj.isDefaulted());
  487. CheckEquals(tmpVal, locObj.getDoubleDefault());
  488. tmpVal := test_suite_utils.RandomRange(Low(Word),High(Word));
  489. locObj.setDefault(tmpVal);
  490. CheckEquals(True, locObj.isDefaulted());
  491. CheckEquals(tmpVal, locObj.getDoubleDefault());
  492. locFac.createNew(s_uri,s_type_object_A);
  493. ok := False;
  494. try
  495. locObj.setDefault(VAL_1);
  496. except
  497. on e : ESDOUnsupportedOperationException do
  498. ok := True;
  499. end;
  500. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  501. end;
  502. {$ENDIF HAS_SDO_DOUBLE}
  503. {$IFDEF HAS_SDO_FLOAT}
  504. procedure TSDOPropertyAsbtract_Test.setDefault_float();
  505. const
  506. PROP_TYPE = FloatType;
  507. VAL_1 : TSDOFloat = 1238653223453;
  508. var
  509. locFac : ISDODataFactory;
  510. locObj : ISDOProperty;
  511. tmpVal : TSDOFloat;
  512. ok : Boolean;
  513. begin
  514. Randomize();
  515. locFac := TSDODataFactory.Create() as ISDODataFactory;
  516. locFac.AddType(s_uri,s_type_object_A,[]);
  517. locFac.AddType(s_uri,s_type_object_B,[]);
  518. locObj := create_obj(
  519. (*Name*) 'p_sample',
  520. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  521. (* Many *) False,
  522. (*Contained*) False,
  523. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  524. (*ReadOnly*) False,
  525. (*Attribute*) True
  526. );
  527. CheckEquals(False, locObj.isDefaulted());
  528. CheckEquals(False, locObj.getBooleanDefault());
  529. CheckEquals(0, locObj.getByteDefault());
  530. {$IFDEF HAS_SDO_CHAR}
  531. CheckEquals(#0, locObj.getCharacterDefault());
  532. {$ENDIF HAS_SDO_CHAR}
  533. {$IFDEF HAS_SDO_CURRENCY}
  534. CheckEquals(0, locObj.getCurrencyDefault());
  535. {$ENDIF HAS_SDO_CURRENCY}
  536. {$IFDEF HAS_SDO_DOUBLE}
  537. CheckEquals(0, locObj.getDoubleDefault());
  538. {$ENDIF HAS_SDO_DOUBLE}
  539. {$IFDEF HAS_SDO_LONG}
  540. CheckEquals(0, locObj.getLongDefault());
  541. {$ENDIF HAS_SDO_LONG}
  542. {$IFDEF HAS_SDO_SHORT}
  543. CheckEquals(0, locObj.getShortDefault());
  544. {$ENDIF HAS_SDO_SHORT}
  545. CheckEquals(0, locObj.getIntegerDefault());
  546. CheckEquals('', locObj.getStringDefault());
  547. CheckEquals(0, locObj.getFloatDefault());
  548. tmpVal := test_suite_utils.RandomRange(Low(Word),High(Word));
  549. locObj.setDefault(tmpVal);
  550. CheckEquals(True, locObj.isDefaulted());
  551. CheckEquals(tmpVal, locObj.getFloatDefault());
  552. tmpVal := test_suite_utils.RandomRange(Low(Word),High(Word));
  553. locObj.setDefault(tmpVal);
  554. CheckEquals(True, locObj.isDefaulted());
  555. CheckEquals(tmpVal, locObj.getFloatDefault());
  556. locFac.createNew(s_uri,s_type_object_A);
  557. ok := False;
  558. try
  559. locObj.setDefault(VAL_1);
  560. except
  561. on e : ESDOUnsupportedOperationException do
  562. ok := True;
  563. end;
  564. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  565. end;
  566. {$ENDIF HAS_SDO_FLOAT}
  567. {$IFDEF HAS_SDO_LONG}
  568. procedure TSDOPropertyAsbtract_Test.setDefault_long();
  569. const
  570. PROP_TYPE = LongType;
  571. var
  572. locFac : ISDODataFactory;
  573. locObj : ISDOProperty;
  574. tmpVal : TSDOLong;
  575. ok : Boolean;
  576. begin
  577. Randomize();
  578. locFac := TSDODataFactory.Create() as ISDODataFactory;
  579. locFac.AddType(s_uri,s_type_object_A,[]);
  580. locFac.AddType(s_uri,s_type_object_B,[]);
  581. locObj := create_obj(
  582. (*Name*) 'p_sample',
  583. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  584. (* Many *) False,
  585. (*Contained*) False,
  586. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  587. (*ReadOnly*) False,
  588. (*Attribute*) True
  589. );
  590. CheckEquals(False, locObj.isDefaulted());
  591. CheckEquals(False, locObj.getBooleanDefault());
  592. CheckEquals(0, locObj.getByteDefault());
  593. {$IFDEF HAS_SDO_CHAR}
  594. CheckEquals(#0, locObj.getCharacterDefault());
  595. {$ENDIF HAS_SDO_CHAR}
  596. CheckEquals(0, locObj.getIntegerDefault());
  597. {$IFDEF HAS_SDO_LONG}
  598. CheckEquals(0, locObj.getLongDefault());
  599. {$ENDIF HAS_SDO_LONG}
  600. {$IFDEF HAS_SDO_SHORT}
  601. CheckEquals(0, locObj.getShortDefault());
  602. {$ENDIF HAS_SDO_SHORT}
  603. CheckEquals('', locObj.getStringDefault());
  604. tmpVal := test_suite_utils.RandomRange(Low(TSDOLong),High(TSDOLong));
  605. locObj.setDefault(tmpVal);
  606. CheckEquals(True, locObj.isDefaulted());
  607. CheckEquals(tmpVal, locObj.getLongDefault());
  608. tmpVal := test_suite_utils.RandomRange(Low(TSDOLong),High(TSDOLong));
  609. locObj.setDefault(tmpVal);
  610. CheckEquals(True, locObj.isDefaulted());
  611. CheckEquals(tmpVal, locObj.getLongDefault());
  612. locFac.createNew(s_uri,s_type_object_A);
  613. ok := False;
  614. try
  615. locObj.setDefault(TSDOLong(123865322345363636));
  616. except
  617. on e : ESDOUnsupportedOperationException do
  618. ok := True;
  619. end;
  620. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  621. end;
  622. {$ENDIF HAS_SDO_LONG}
  623. {$IFDEF HAS_SDO_SHORT}
  624. procedure TSDOPropertyAsbtract_Test.setDefault_short();
  625. const
  626. PROP_TYPE = ShortType;
  627. var
  628. locFac : ISDODataFactory;
  629. locObj : ISDOProperty;
  630. tmpVal : TSDOShort;
  631. ok : Boolean;
  632. begin
  633. Randomize();
  634. locFac := TSDODataFactory.Create() as ISDODataFactory;
  635. locFac.AddType(s_uri,s_type_object_A,[]);
  636. locFac.AddType(s_uri,s_type_object_B,[]);
  637. locObj := create_obj(
  638. (*Name*) 'p_sample',
  639. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[PROP_TYPE]),
  640. (* Many *) False,
  641. (*Contained*) False,
  642. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  643. (*ReadOnly*) False,
  644. (*Attribute*) True
  645. );
  646. CheckEquals(False, locObj.isDefaulted());
  647. CheckEquals(False, locObj.getBooleanDefault());
  648. CheckEquals(0, locObj.getByteDefault());
  649. {$IFDEF HAS_SDO_CHAR}
  650. CheckEquals(#0, locObj.getCharacterDefault());
  651. {$ENDIF HAS_SDO_CHAR}
  652. CheckEquals(0, locObj.getIntegerDefault());
  653. {$IFDEF HAS_SDO_LONG}
  654. CheckEquals(0, locObj.getLongDefault());
  655. {$ENDIF HAS_SDO_LONG}
  656. {$IFDEF HAS_SDO_SHORT}
  657. CheckEquals(0, locObj.getShortDefault());
  658. {$ENDIF HAS_SDO_SHORT}
  659. CheckEquals('', locObj.getStringDefault());
  660. tmpVal := RandomRange(Low(TSDOShort),High(TSDOShort));
  661. locObj.setDefault(tmpVal);
  662. CheckEquals(True, locObj.isDefaulted());
  663. CheckEquals(tmpVal, locObj.getShortDefault());
  664. tmpVal := RandomRange(Low(TSDOShort),High(TSDOShort));
  665. locObj.setDefault(tmpVal);
  666. CheckEquals(True, locObj.isDefaulted());
  667. CheckEquals(tmpVal, locObj.getShortDefault());
  668. locFac.createNew(s_uri,s_type_object_A);
  669. ok := False;
  670. try
  671. locObj.setDefault(TSDOShort(12386));
  672. except
  673. on e : ESDOUnsupportedOperationException do
  674. ok := True;
  675. end;
  676. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  677. end;
  678. {$ENDIF HAS_SDO_SHORT}
  679. procedure TSDOPropertyAsbtract_Test.setDefault_object;
  680. var
  681. locFac : ISDODataFactory;
  682. locObj : ISDOProperty;
  683. ok : boolean;
  684. begin
  685. locFac := TSDODataFactory.Create() as ISDODataFactory;
  686. locFac.AddType(s_uri,s_type_object_A,[]);
  687. locFac.AddType(s_uri,s_type_object_B,[]);
  688. locObj := create_obj(
  689. (*Name*) 'p_string',
  690. (*Type*) locFac.getType(s_uri,s_type_object_B),
  691. (* Many *) False,
  692. (*Contained*) False,
  693. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  694. (*ReadOnly*) False,
  695. (*Attribute*) False
  696. );
  697. CheckEquals(False, locObj.isDefaulted());
  698. ok := False;
  699. try
  700. locObj.setDefault('asa');
  701. except
  702. on e : ESDOUnsupportedOperationException do
  703. ok := True;
  704. end;
  705. Check(ok, 'setDefault(string)');
  706. ok := False;
  707. try
  708. locObj.setDefault(True);
  709. except
  710. on e : ESDOUnsupportedOperationException do
  711. ok := True;
  712. end;
  713. Check(ok, 'setDefault(Boolean)');
  714. ok := False;
  715. try
  716. locObj.setDefault(1210);
  717. except
  718. on e : ESDOUnsupportedOperationException do
  719. ok := True;
  720. end;
  721. Check(ok, 'setDefault(Integer)');
  722. end;
  723. procedure TSDOPropertyAsbtract_Test.setDefault_string();
  724. var
  725. locFac : ISDODataFactory;
  726. locObj : ISDOProperty;
  727. tmpVal : TSDOString;
  728. ok : Boolean;
  729. begin
  730. Randomize();
  731. locFac := TSDODataFactory.Create() as ISDODataFactory;
  732. locFac.AddType(s_uri,s_type_object_A,[]);
  733. locFac.AddType(s_uri,s_type_object_B,[]);
  734. locObj := create_obj(
  735. (*Name*) 'p_string',
  736. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  737. (* Many *) False,
  738. (*Contained*) False,
  739. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  740. (*ReadOnly*) False,
  741. (*Attribute*) True
  742. );
  743. CheckEquals(False, locObj.isDefaulted());
  744. CheckEquals(False, locObj.getBooleanDefault());
  745. CheckEquals(0, locObj.getIntegerDefault());
  746. CheckEquals('', locObj.getStringDefault());
  747. tmpVal := RandomString(RandomRange(1,1000));
  748. locObj.setDefault(tmpVal);
  749. CheckEquals(True, locObj.isDefaulted());
  750. CheckEquals(tmpVal, locObj.getStringDefault());
  751. tmpVal := RandomString(RandomRange(1,1000));
  752. locObj.setDefault(tmpVal);
  753. CheckEquals(True, locObj.isDefaulted());
  754. CheckEquals(tmpVal, locObj.getStringDefault());
  755. locFac.createNew(s_uri,s_type_object_A);
  756. ok := False;
  757. try
  758. locObj.setDefault('azerty');
  759. except
  760. on e : ESDOUnsupportedOperationException do
  761. ok := True;
  762. end;
  763. Check(ok, 'Once an instance has been created, the metadata becomes read-only.');
  764. end;
  765. procedure TSDOPropertyAsbtract_Test.test_create();
  766. procedure check_invalid_args(
  767. const AName : string;
  768. const AType : ISDOType;
  769. const AMany : Boolean;
  770. const AContained : Boolean;
  771. const AContainingType : ISDOType;
  772. const AReadOnly : Boolean;
  773. const AIsAttribute : Boolean;
  774. const AMsg : string
  775. );
  776. var
  777. ok : Boolean;
  778. begin
  779. ok := False;
  780. try
  781. create_obj(AName,AType,AMany,AContained,AContainingType,AReadOnly,AIsAttribute);
  782. except
  783. on e : ESDOIllegalArgumentException do
  784. ok := True;
  785. end;
  786. Check(ok, AMsg);
  787. end;
  788. var
  789. locFac : ISDODataFactory;
  790. locObj : ISDOProperty;
  791. begin
  792. locFac := TSDODataFactory.Create() as ISDODataFactory;
  793. locFac.AddType(s_uri,s_type_object_A,[]);
  794. locFac.AddType(s_uri,s_type_object_B,[]);
  795. check_invalid_args(
  796. (*Name*) '',
  797. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  798. (* Many *) False,
  799. (*Contained*) False,
  800. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  801. (*ReadOnly*) False,
  802. (*Attribute*) True,
  803. 'Invalid Name.'
  804. );
  805. check_invalid_args(
  806. (*Name*) '1az',
  807. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  808. (* Many *) False,
  809. (*Contained*) False,
  810. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  811. (*ReadOnly*) False,
  812. (*Attribute*) True,
  813. 'Invalid Name.'
  814. );
  815. check_invalid_args(
  816. (*Name*) 'ab[1]',
  817. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  818. (* Many *) False,
  819. (*Contained*) False,
  820. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  821. (*ReadOnly*) False,
  822. (*Attribute*) True,
  823. 'Invalid Name.'
  824. );
  825. check_invalid_args(
  826. (*Name*) 'azerty',
  827. (*Type*) nil,
  828. (* Many *) False,
  829. (*Contained*) False,
  830. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  831. (*ReadOnly*) False,
  832. (*Attribute*) True,
  833. 'Invalid type.'
  834. );
  835. check_invalid_args(
  836. (*Name*) 'azerty',
  837. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  838. (* Many *) False,
  839. (*Contained*) True,
  840. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  841. (*ReadOnly*) False,
  842. (*Attribute*) True,
  843. 'Invalid Contained.'
  844. );
  845. check_invalid_args(
  846. (*Name*) 'azerty',
  847. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  848. (* Many *) False,
  849. (*Contained*) True,
  850. (*ContainingType*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[IntegerType]),
  851. (*ReadOnly*) False,
  852. (*Attribute*) True,
  853. 'Invalid containingType : The containing type must be a DataObject.'
  854. );
  855. locObj := create_obj(
  856. (*Name*) 'p_string',
  857. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  858. (* Many *) False,
  859. (*Contained*) False,
  860. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  861. (*ReadOnly*) False,
  862. (*Attribute*) True
  863. );
  864. CheckEquals('p_string', locObj.getName(), 'Name');
  865. Check(locObj.getType().equals(locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType])), 'Type');
  866. CheckEquals(False, locObj.isMany(), 'isMany');
  867. CheckEquals(False, locObj.isReadOnly(), 'isReadOnly');
  868. CheckEquals(False, locObj.isContainment(), 'isContainment');
  869. CheckEquals(Ord(locObj.getType().getTypeEnum), Ord(locObj.getTypeEnum()), 'getTypeEnum');
  870. CheckEquals(False, locObj.isReference(), 'isReference');
  871. CheckEquals(True, locObj.isAttribute(), 'isAttribute');
  872. CheckEquals(False, locObj.isDefaulted(), 'isDefaulted');
  873. locObj := create_obj(
  874. (*Name*) 'p_string',
  875. (*Type*) locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType]),
  876. (* Many *) False,
  877. (*Contained*) False,
  878. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  879. (*ReadOnly*) False,
  880. (*Attribute*) False
  881. );
  882. CheckEquals('p_string', locObj.getName(), 'Name');
  883. Check(locObj.getType().equals(locFac.getType(sdo_namespace,SDOTypeDefaultTypeNames[StringType])), 'Type');
  884. CheckEquals(False, locObj.isMany(), 'isMany');
  885. CheckEquals(False, locObj.isReadOnly(), 'isReadOnly');
  886. CheckEquals(False, locObj.isContainment(), 'isContainment');
  887. CheckEquals(Ord(locObj.getType().getTypeEnum), Ord(locObj.getTypeEnum()), 'getTypeEnum');
  888. CheckEquals(False, locObj.isReference(), 'isReference');
  889. CheckEquals(False, locObj.isAttribute(), 'isAttribute');
  890. CheckEquals(False, locObj.isDefaulted(), 'isDefaulted');
  891. locObj := create_obj(
  892. (*Name*) 'p_ab',
  893. (*Type*) locFac.getType(s_uri,s_type_object_B),
  894. (* Many *) False,
  895. (*Contained*) False,
  896. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  897. (*ReadOnly*) False,
  898. (*Attribute*) False
  899. );
  900. CheckEquals('p_ab', locObj.getName(), 'Name');
  901. Check(locObj.getType().equals(locFac.getType(s_uri,s_type_object_B)), 'Type');
  902. CheckEquals(False, locObj.isMany(), 'isMany');
  903. CheckEquals(False, locObj.isReadOnly(), 'isReadOnly');
  904. CheckEquals(False, locObj.isContainment(), 'isContainment');
  905. CheckEquals(Ord(locObj.getType().getTypeEnum), Ord(locObj.getTypeEnum()), 'getTypeEnum');
  906. CheckEquals(True, locObj.isReference(), 'isReference');
  907. CheckEquals(False, locObj.isDefaulted(), 'isDefaulted');
  908. locObj := create_obj(
  909. (*Name*) 'p_ab2',
  910. (*Type*) locFac.getType(s_uri,s_type_object_B),
  911. (* Many *) False,
  912. (*Contained*) True,
  913. (*ContainingType*) locFac.getType(s_uri,s_type_object_A),
  914. (*ReadOnly*) False,
  915. (*Attribute*) False
  916. );
  917. CheckEquals('p_ab2', locObj.getName(), 'Name');
  918. Check(locObj.getType().equals(locFac.getType(s_uri,s_type_object_B)), 'Type');
  919. CheckEquals(False, locObj.isMany(), 'isMany');
  920. CheckEquals(False, locObj.isReadOnly(), 'isReadOnly');
  921. CheckEquals(True, locObj.isContainment(), 'isContainment');
  922. CheckEquals(Ord(locObj.getType().getTypeEnum), Ord(locObj.getTypeEnum()), 'getTypeEnum');
  923. CheckEquals(False, locObj.isReference(), 'isReference');
  924. CheckEquals(False, locObj.isDefaulted(), 'isDefaulted');
  925. end;
  926. { TSDOProperty_Test }
  927. class function TSDOProperty_Test.create_obj(
  928. const AName: string;
  929. const AType: ISDOType;
  930. const AMany, AContained: Boolean;
  931. const AContainingType: ISDOType;
  932. const AReadOnly: Boolean;
  933. const AIsAttribute : Boolean
  934. ): ISDOProperty;
  935. var
  936. f : TPropertyFlags;
  937. begin
  938. f := [];
  939. if AMany then
  940. Include(f, pfIsMany);
  941. if AContained then
  942. Include(f, pfIsContainment);
  943. if AReadOnly then
  944. Include(f, pfIsReadOnly);
  945. if AIsAttribute then
  946. Include(f, pfIsAttribute);
  947. Result := TSDOProperty.Create(AName,AType,f,AContainingType) as ISDOProperty;
  948. end;
  949. initialization
  950. RegisterTest('Metadata',TSDOProperty_Test.Suite);
  951. end.