Loading...
Searching...
No Matches
TestGAMSOptions.cs
1using System;
2using System.Collections.Generic;
3using System.IO;
4using System.Linq;
5using GAMS;
6using NLog;
7using NUnit.Framework;
8
9namespace GamsApiTests
10{
11 [TestFixture]
12 class TestGAMSOptions
13 {
14
15 static readonly String PROPERTIES_FILE = "test.properties";
16 static String workingDir;
17 static GAMSWorkspaceInfo wsInfo = null;
18 static GAMSWorkspace ws = null;
19 static GAMSDatabase db = null;
20 static GAMSWorkspace globalWS;
21 static GAMSOptions globalOpt;
22 static Logger logger = LogManager.GetCurrentClassLogger();
23
24 [OneTimeSetUp]
25 public static void OneTimeSetup()
26 {
27 logger.Debug("TestGAMSOptions | OneTimeSetup");
28 workingDir = HouseKeeper.gamsAbsoluteWorkingDir;
29 HouseKeeper.initializeTestFrom(PROPERTIES_FILE, "TestGAMSOptions");
30 logger.Debug("TestGAMSOptions | oneTimeSetup");
31
32 GAMSWorkspaceInfo wsInfo = new GAMSWorkspaceInfo();
33 wsInfo.WorkingDirectory = (HouseKeeper.gamsWorkingDir);
34 wsInfo.SystemDirectory = (HouseKeeper.gamsSystemDir);
35 wsInfo.Debug = DebugLevel.Off;
36 globalWS = new GAMSWorkspace(wsInfo);
37 globalOpt = globalWS.AddOptions();
38
39 }
40
41 [OneTimeTearDown]
42 public static void OneTimeTearDown()
43 {
44 if (globalOpt != null)
45 globalOpt.Dispose();
46 File.Delete(HouseKeeper.gamsWorkingDir);
47 }
48
49 [Test]
50 public void TestEnumAction()
51 {
52 logger.Debug("Entering TestGAMSOptions | testEnumAction");
53
54 globalOpt.Action = GAMSOptions.EAction.RestartAfterSolve;
55 Assert.AreEqual(GAMSOptions.EAction.RestartAfterSolve, globalOpt.Action, "expect same options " + GAMSOptions.EAction.RestartAfterSolve + " set");
56
57 globalOpt.Action = GAMSOptions.EAction.CompileOnly;
58 Assert.AreEqual(GAMSOptions.EAction.CompileOnly, globalOpt.Action, "expect same options " + GAMSOptions.EAction.CompileOnly + " set");
59
60 globalOpt.Action = GAMSOptions.EAction.ExecuteOnly;
61 Assert.AreEqual(GAMSOptions.EAction.ExecuteOnly, globalOpt.Action, "expect same options " + GAMSOptions.EAction.ExecuteOnly + " set");
62
63 globalOpt.Action = GAMSOptions.EAction.CompileAndExecute;
64 Assert.AreEqual(GAMSOptions.EAction.CompileAndExecute, globalOpt.Action, "expect same options " + GAMSOptions.EAction.CompileAndExecute + " set");
65
66 globalOpt.Action = GAMSOptions.EAction.GlueCodeGeneration;
67 Assert.AreEqual(GAMSOptions.EAction.GlueCodeGeneration, globalOpt.Action, "expect same options " + GAMSOptions.EAction.GlueCodeGeneration + " set");
68
69 globalOpt.Action = GAMSOptions.EAction.TraceReport;
70 Assert.AreEqual(GAMSOptions.EAction.TraceReport, globalOpt.Action, "expect same options " + GAMSOptions.EAction.TraceReport + " set");
71
72 logger.Debug("Exiting TestGAMSOptions | testEnumAction");
73 }
74
75
77 //[Test]
78 //public void TestLookupEnumAction()
79 //{
80 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAction");
81
82 // Assert.AreEqual("Lookup R from EAction", GAMSOptions.EAction.RestartAfterSolve, GAMSOptions.EAction.lookup("R"));
83 // Assert.AreEqual("Lookup C from EAction", GAMSOptions.EAction.CompileOnly, GAMSOptions.EAction.lookup("C"));
84 // Assert.AreEqual("Lookup E from EAction", GAMSOptions.EAction.ExecuteOnly, GAMSOptions.EAction.lookup("E"));
85 // Assert.AreEqual("Lookup CE from EAction", GAMSOptions.EAction.CompileAndExecute, GAMSOptions.EAction.lookup("CE"));
86 // Assert.AreEqual("Lookup G from EAction", GAMSOptions.EAction.GlueCodeGeneration, GAMSOptions.EAction.lookup("G"));
87 // Assert.AreEqual("Lookup GT from EAction", GAMSOptions.EAction.TraceReport, GAMSOptions.EAction.lookup("GT"));
88
89 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAction");
90 //}
91
92 [Test]
93 public void TestEnumAppendExpand()
94 {
95 logger.Debug("Entering TestGAMSOptions | testEnumAppendExpand");
96
97 globalOpt.AppendExpand = (GAMSOptions.EAppendExpand.Reset);
98 Assert.AreEqual(GAMSOptions.EAppendExpand.Reset, globalOpt.AppendExpand, "expect same options " + GAMSOptions.EAppendExpand.Reset + " set");
99
100 globalOpt.AppendExpand = (GAMSOptions.EAppendExpand.Append);
101 Assert.AreEqual(GAMSOptions.EAppendExpand.Append, globalOpt.AppendExpand, "expect same options " + GAMSOptions.EAppendExpand.Append + " set");
102
103 logger.Debug("Exiting TestGAMSOptions | testEnumAppendExpand");
104 }
105
106 //[Test]
107 //public void TestLookupEnumAppendExpand()
108 //{
109 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAppendExpand");
110
111 // Assert.AreEqual("Lookup Reset from EAppendExpand", GAMSOptions.EAppendExpand.Reset, GAMSOptions.EAppendExpand.lookup(0));
112 // Assert.AreEqual("Lookup Append from EAppendExpand", GAMSOptions.EAppendExpand.Append, GAMSOptions.EAppendExpand.lookup(1));
113
114 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAppendExpand");
115 //}
116
117
118 [Test]
119 public void TestEnumAppendOut()
120 {
121 logger.Debug("Entering TestGAMSOptions | testEnumAppendOut");
122
123 globalOpt.AppendOut = (GAMSOptions.EAppendOut.Reset);
124 Assert.AreEqual(GAMSOptions.EAppendOut.Reset, globalOpt.AppendOut, "expect same options " + GAMSOptions.EAppendOut.Reset + " set");
125
126 globalOpt.AppendOut = (GAMSOptions.EAppendOut.Append);
127 Assert.AreEqual(GAMSOptions.EAppendOut.Append, globalOpt.AppendOut, "expect same options " + GAMSOptions.EAppendOut.Append + " set");
128
129 logger.Debug("Exiting TestGAMSOptions | testEnumAppendOut");
130 }
131
132 //[Test]
133 //public void TestLookupEnumAppendOut()
134 //{
135 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAppendOut");
136
137 // Assert.AreEqual("Lookup Reset from EAppendOut", GAMSOptions.EAppendOut.Reset, GAMSOptions.EAppendOut.lookup(0));
138 // Assert.AreEqual("Lookup Append from EAppendOut", GAMSOptions.EAppendOut.Append, GAMSOptions.EAppendOut.lookup(1));
139
140 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAppendOut");
141 //}
142
143
144 [Test]
145 public void TestEnumAsyncSolLst()
146 {
147 logger.Debug("Entering TestGAMSOptions | testEnumAsyncSolLst");
148
149 globalOpt.AsyncSolLst = (GAMSOptions.EAsyncSolLst.Off);
150 Assert.AreEqual(GAMSOptions.EAsyncSolLst.Off, globalOpt.AsyncSolLst, "expect same options " + GAMSOptions.EAsyncSolLst.Off + " set");
151
152 globalOpt.AsyncSolLst = (GAMSOptions.EAsyncSolLst.On);
153 Assert.AreEqual(GAMSOptions.EAsyncSolLst.On, globalOpt.AsyncSolLst, "expect same options " + GAMSOptions.EAsyncSolLst.On + " set");
154
155 logger.Debug("Exiting TestGAMSOptions | testEnumAsyncSolLst");
156 }
157
158 //[Test]
159 //public void TestLookupEnumAsyncSolLst()
160 //{
161 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAsyncSolLst");
162
163 // Assert.AreEqual("Lookup Off from EAsyncSolLst", GAMSOptions.EAsyncSolLst.Off, GAMSOptions.EAsyncSolLst.lookup(0));
164 // Assert.AreEqual("Lookup On from EAsyncSolLst", GAMSOptions.EAsyncSolLst.On, GAMSOptions.EAsyncSolLst.lookup(1));
165
166 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAsyncSolLst");
167 //}
168
169
170 [Test]
171 public void TestEnumCaptureModelInstance()
172 {
173 logger.Debug("Entering TestGAMSOptions | testEnumCaptureModelInstance");
174
175 globalOpt.CaptureModelInstance = (GAMSOptions.ECaptureModelInstance.Off);
176 Assert.AreEqual(GAMSOptions.ECaptureModelInstance.Off, globalOpt.CaptureModelInstance, "expect same options " + GAMSOptions.ECaptureModelInstance.Off + " set");
177
178 globalOpt.CaptureModelInstance = (GAMSOptions.ECaptureModelInstance.On);
179 Assert.AreEqual(GAMSOptions.ECaptureModelInstance.On, globalOpt.CaptureModelInstance, "expect same options " + GAMSOptions.ECaptureModelInstance.On + " set");
180
181 logger.Debug("Exiting TestGAMSOptions | testEnumCaptureModelInstance");
182 }
183
184 //[Test]
185 //public void TestLookupEnumCaptureModelInstance()
186 //{
187 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCaptureModelInstance");
188
189 // Assert.AreEqual("Lookup Off from ECaptureModelInstance", GAMSOptions.ECaptureModelInstance.Off, GAMSOptions.ECaptureModelInstance.lookup(0));
190 // Assert.AreEqual("Lookup On from ECaptureModelInstance", GAMSOptions.ECaptureModelInstance.On, GAMSOptions.ECaptureModelInstance.lookup(1));
191
192 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCaptureModelInstance");
193 //}
194
195
196 [Test]
197 public void TestEnumCase()
198 {
199 logger.Debug("Entering TestGAMSOptions | testEnumCase");
200
201 globalOpt.Case = (GAMSOptions.ECase.MixedCase);
202 Assert.AreEqual(GAMSOptions.ECase.MixedCase, globalOpt.Case, "expect same options " + GAMSOptions.ECase.MixedCase + " set");
203
204 globalOpt.Case = (GAMSOptions.ECase.UpperCase);
205 Assert.AreEqual(GAMSOptions.ECase.UpperCase, globalOpt.Case, "expect same options " + GAMSOptions.ECase.UpperCase + " set");
206
207 logger.Debug("Exiting TestGAMSOptions | testEnumCase");
208 }
209
210 //[Test]
211 //public void TestLookupEnumCase()
212 //{
213 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCase");
214
215 // Assert.AreEqual("Lookup MixedCase from ECase", GAMSOptions.ECase.MixedCase, GAMSOptions.ECase.lookup(0));
216 // Assert.AreEqual("Lookup UpperCase from ECase", GAMSOptions.ECase.UpperCase, GAMSOptions.ECase.lookup(1));
217
218 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCase");
219 //}
220
221
222 [Test]
223 public void TestEnumCharSet()
224 {
225 logger.Debug("Entering TestGAMSOptions | testEnumCharSet");
226
227 globalOpt.CharSet = (GAMSOptions.ECharSet.LimitedGAMSCharSet);
228 Assert.AreEqual(GAMSOptions.ECharSet.LimitedGAMSCharSet, globalOpt.CharSet, "expect same options " + GAMSOptions.ECharSet.LimitedGAMSCharSet + " set");
229
230 globalOpt.CharSet = (GAMSOptions.ECharSet.AnyChar);
231 Assert.AreEqual(GAMSOptions.ECharSet.AnyChar, globalOpt.CharSet, "expect same options " + GAMSOptions.ECharSet.AnyChar + " set");
232
233 logger.Debug("Exiting TestGAMSOptions | testEnumCharSet");
234 }
235
236 //[Test]
237 //public void TestLookupEnumCharSet()
238 //{
239 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCharSet");
240
241 // Assert.AreEqual("Lookup LimitedGAMSCharSet from ECharSet", GAMSOptions.ECharSet.LimitedGAMSCharSet, GAMSOptions.ECharSet.lookup(0));
242 // Assert.AreEqual("Lookup AnyChar from ECharSet", GAMSOptions.ECharSet.AnyChar, GAMSOptions.ECharSet.lookup(1));
243
244 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCharSet");
245 //}
246
247
248 [Test]
249 public void TestEnumCheckErrorLevel()
250 {
251 logger.Debug("Entering TestGAMSOptions | testEnumCheckErrorLevel");
252
253 globalOpt.CheckErrorLevel = (GAMSOptions.ECheckErrorLevel.Off);
254 Assert.AreEqual(GAMSOptions.ECheckErrorLevel.Off, globalOpt.CheckErrorLevel, "expect same options " + GAMSOptions.ECheckErrorLevel.Off + " set");
255
256 globalOpt.CheckErrorLevel = (GAMSOptions.ECheckErrorLevel.On);
257 Assert.AreEqual(GAMSOptions.ECheckErrorLevel.On, globalOpt.CheckErrorLevel, "expect same options " + GAMSOptions.ECheckErrorLevel.On + " set");
258
259 logger.Debug("Exiting TestGAMSOptions | testEnumCheckErrorLevel");
260 }
261
262 //[Test]
263 //public void TestLookupEnumCheckErrorLevel()
264 //{
265 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCheckErrorLevel");
266
267 // Assert.AreEqual("Lookup Off from ECheckErrorLevel", GAMSOptions.ECheckErrorLevel.Off, GAMSOptions.ECheckErrorLevel.lookup(0));
268 // Assert.AreEqual("Lookup On from ECheckErrorLevel", GAMSOptions.ECheckErrorLevel.On, GAMSOptions.ECheckErrorLevel.lookup(1));
269
270 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCheckErrorLevel");
271 //}
272
273
274 [Test]
275 public void TestEnumDFormat()
276 {
277 logger.Debug("Entering TestGAMSOptions | testEnumDFormat");
278
279 globalOpt.DFormat = (GAMSOptions.EDFormat.Slash);
280 Assert.AreEqual(GAMSOptions.EDFormat.Slash, globalOpt.DFormat, "expect same options " + GAMSOptions.EDFormat.Slash + " set");
281
282 globalOpt.DFormat = (GAMSOptions.EDFormat.Dot);
283 Assert.AreEqual(GAMSOptions.EDFormat.Dot, globalOpt.DFormat, "expect same options " + GAMSOptions.EDFormat.Dot + " set");
284
285 globalOpt.DFormat = (GAMSOptions.EDFormat.Dash);
286 Assert.AreEqual(GAMSOptions.EDFormat.Dash, globalOpt.DFormat, "expect same options " + GAMSOptions.EDFormat.Dash + " set");
287
288 logger.Debug("Exiting TestGAMSOptions | testEnumDFormat");
289 }
290
291 //[Test]
292 //public void TestLookupEnumDFormat()
293 //{
294 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDFormat");
295
296 // Assert.AreEqual("Lookup Slash from EDFormat", GAMSOptions.EDFormat.Slash, GAMSOptions.EDFormat.lookup(0));
297 // Assert.AreEqual("Lookup Dot from EDFormat", GAMSOptions.EDFormat.Dot, GAMSOptions.EDFormat.lookup(1));
298 // Assert.AreEqual("Lookup Dash from EDFormat", GAMSOptions.EDFormat.Dash, GAMSOptions.EDFormat.lookup(2));
299
300 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDFormat");
301 //}
302
303
304 [Test]
305 public void TestEnumDigit()
306 {
307 logger.Debug("Entering TestGAMSOptions | testEnumDigit");
308
309 globalOpt.Digit = (GAMSOptions.EDigit.OffDigit);
310 Assert.AreEqual(GAMSOptions.EDigit.OffDigit, globalOpt.Digit, "expect same options " + GAMSOptions.EDigit.OffDigit + " set");
311
312 globalOpt.Digit = (GAMSOptions.EDigit.OnDigit);
313 Assert.AreEqual(GAMSOptions.EDigit.OnDigit, globalOpt.Digit, "expect same options " + GAMSOptions.EDigit.OnDigit + " set");
314
315 logger.Debug("Exiting TestGAMSOptions | testEnumDigit");
316 }
317
318 //[Test]
319 //public void TestLookupEnumDigit()
320 //{
321 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDigit");
322
323 // Assert.AreEqual("Lookup off from EDigit", GAMSOptions.EDigit.OffDigit, GAMSOptions.EDigit.lookup("off"));
324 // Assert.AreEqual("Lookup on from EDigit", GAMSOptions.EDigit.OnDigit, GAMSOptions.EDigit.lookup("on"));
325
326 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDigit");
327 //}
328
329
330 [Test]
331 public void TestEnumDumpOpt()
332 {
333 logger.Debug("Entering TestGAMSOptions | testEnumDumpOpt");
334
335 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.No);
336 Assert.AreEqual(GAMSOptions.EDumpOpt.No, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.No + " set");
337
338 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames);
339 Assert.AreEqual(GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames + " set");
340
341 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefDataNewSetElementNames);
342 Assert.AreEqual(GAMSOptions.EDumpOpt.RefDataNewSetElementNames, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefDataNewSetElementNames + " set");
343
344 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText);
345 Assert.AreEqual(GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText + " set");
346
347 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefSymbol);
348 Assert.AreEqual(GAMSOptions.EDumpOpt.RefSymbol, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefSymbol + " set");
349
350 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_10);
351 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_10, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_10 + " set");
352
353 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.InputFileWOComments);
354 Assert.AreEqual(GAMSOptions.EDumpOpt.InputFileWOComments, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.InputFileWOComments + " set");
355
356 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_12);
357 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_12, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_12 + " set");
358
359 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_19);
360 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_19, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_19 + " set");
361
362 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_20);
363 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_20, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_20 + " set");
364
365 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.InputFileWithComments);
366 Assert.AreEqual(GAMSOptions.EDumpOpt.InputFileWithComments, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.InputFileWithComments + " set");
367
368 logger.Debug("Exiting TestGAMSOptions | testEnumDumpOpt");
369 }
370
371 //[Test]
372 //public void TestLookupEnumDumpOpt()
373 //{
374 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDumpOpt");
375
376 // Assert.AreEqual("Lookup No from EDumpOpt", GAMSOptions.EDumpOpt.No, GAMSOptions.EDumpOpt.lookup(0));
377 // Assert.AreEqual("Lookup RefDataOriginalSetElementNames from EDumpOpt", GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames, GAMSOptions.EDumpOpt.lookup(1));
378 // Assert.AreEqual("Lookup RefDataNewSetElementNames from EDumpOpt", GAMSOptions.EDumpOpt.RefDataNewSetElementNames, GAMSOptions.EDumpOpt.lookup(2));
379 // Assert.AreEqual("Lookup RefDataNewSetElementNamesDropSymbolText from EDumpOpt", GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText, GAMSOptions.EDumpOpt.lookup(3));
380 // Assert.AreEqual("Lookup RefSymbol from EDumpOpt", GAMSOptions.EDumpOpt.RefSymbol, GAMSOptions.EDumpOpt.lookup(4));
381 // Assert.AreEqual("Lookup Deprecated_10 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_10, GAMSOptions.EDumpOpt.lookup(10));
382 // Assert.AreEqual("Lookup InputFileWOComments from EDumpOpt", GAMSOptions.EDumpOpt.InputFileWOComments, GAMSOptions.EDumpOpt.lookup(11));
383 // Assert.AreEqual("Lookup Deprecated_12 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_12, GAMSOptions.EDumpOpt.lookup(12));
384 // Assert.AreEqual("Lookup Deprecated_19 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_19, GAMSOptions.EDumpOpt.lookup(19));
385 // Assert.AreEqual("Lookup Deprecated_20 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_20, GAMSOptions.EDumpOpt.lookup(20));
386 // Assert.AreEqual("Lookup InputFileWithComments from EDumpOpt", GAMSOptions.EDumpOpt.InputFileWithComments, GAMSOptions.EDumpOpt.lookup(21));
387
388 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDumpOpt");
389 //}
390
391
392 [Test]
393 public void TestEnumDumpParms()
394 {
395 logger.Debug("Entering TestGAMSOptions | testEnumDumpParms");
396
397 globalOpt.DumpParms = (GAMSOptions.EDumpParms.No);
398 Assert.AreEqual(GAMSOptions.EDumpParms.No, globalOpt.DumpParms, "expect same options " + GAMSOptions.EDumpParms.No + " set");
399
400 globalOpt.DumpParms = (GAMSOptions.EDumpParms.AcceptedParameters);
401 Assert.AreEqual(GAMSOptions.EDumpParms.AcceptedParameters, globalOpt.DumpParms, "expect same options " + GAMSOptions.EDumpParms.AcceptedParameters + " set");
402
403 globalOpt.DumpParms = (GAMSOptions.EDumpParms.FileOperationsAcceptedParameters);
404 Assert.AreEqual(GAMSOptions.EDumpParms.FileOperationsAcceptedParameters, globalOpt.DumpParms, "expect same options " + GAMSOptions.EDumpParms.FileOperationsAcceptedParameters + " set");
405
406 logger.Debug("Exiting TestGAMSOptions | testEnumDumpParms");
407 }
408
409 //[Test]
410 //public void TestLookupEnumDumpParms()
411 //{
412 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDumpParms");
413
414 // Assert.AreEqual("Lookup No from EDumpParms", GAMSOptions.EDumpParms.No, GAMSOptions.EDumpParms.lookup(0));
415 // Assert.AreEqual("Lookup AcceptedParameters from EDumpParms", GAMSOptions.EDumpParms.AcceptedParameters, GAMSOptions.EDumpParms.lookup(1));
416 // Assert.AreEqual("Lookup FileOperationsAcceptedParameters from EDumpParms", GAMSOptions.EDumpParms.FileOperationsAcceptedParameters, GAMSOptions.EDumpParms.lookup(2));
417
418 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDumpParms");
419 //}
420
421
422 [Test]
423 public void TestEnumECImplicitLoad()
424 {
425 logger.Debug("Entering TestGAMSOptions | testEnumECImplicitLoad");
426
427 globalOpt.ECImplicitLoad = (GAMSOptions.EECImplicitLoad.OffECImplicitLoad);
428 Assert.AreEqual(GAMSOptions.EECImplicitLoad.OffECImplicitLoad, globalOpt.ECImplicitLoad, "expect same options " + GAMSOptions.EECImplicitLoad.OffECImplicitLoad + " set");
429
430 globalOpt.ECImplicitLoad = (GAMSOptions.EECImplicitLoad.OnECImplicitLoad);
431 Assert.AreEqual(GAMSOptions.EECImplicitLoad.OnECImplicitLoad, globalOpt.ECImplicitLoad, "expect same options " + GAMSOptions.EECImplicitLoad.OnECImplicitLoad + " set");
432
433 logger.Debug("Exiting TestGAMSOptions | testEnumECImplicitLoad");
434 }
435
436 //[Test]
437 //public void TestLookupEnumECImplicitLoad()
438 //{
439 // logger.Debug("Entering TestGAMSOptions | testLookupEnumECImplicitLoad");
440
441 // Assert.AreEqual("Lookup off from EECImplicitLoad", GAMSOptions.EECImplicitLoad.OffECImplicitLoad, GAMSOptions.EECImplicitLoad.lookup("off"));
442 // Assert.AreEqual("Lookup on from EECImplicitLoad", GAMSOptions.EECImplicitLoad.OnECImplicitLoad, GAMSOptions.EECImplicitLoad.lookup("on"));
443
444 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumECImplicitLoad");
445 //}
446
447
448 [Test]
449 public void TestEnumEmpty()
450 {
451 logger.Debug("Entering TestGAMSOptions | testEnumEmpty");
452
453 globalOpt.Empty = (GAMSOptions.EEmpty.OffEmpty);
454 Assert.AreEqual(GAMSOptions.EEmpty.OffEmpty, globalOpt.Empty, "expect same options " + GAMSOptions.EEmpty.OffEmpty + " set");
455
456 globalOpt.Empty = (GAMSOptions.EEmpty.OnEmpty);
457 Assert.AreEqual(GAMSOptions.EEmpty.OnEmpty, globalOpt.Empty, "expect same options " + GAMSOptions.EEmpty.OnEmpty + " set");
458
459 logger.Debug("Exiting TestGAMSOptions | testEnumEmpty");
460 }
461
462 //[Test]
463 //public void TestLookupEnumEmpty()
464 //{
465 // logger.Debug("Entering TestGAMSOptions | testLookupEnumEmpty");
466
467 // Assert.AreEqual("Lookup off from EEmpty", GAMSOptions.EEmpty.OffEmpty, GAMSOptions.EEmpty.lookup("off"));
468 // Assert.AreEqual("Lookup on from EEmpty", GAMSOptions.EEmpty.OnEmpty, GAMSOptions.EEmpty.lookup("on"));
469
470 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumEmpty");
471 //}
472
473
474 [Test]
475 public void TestEnumErrMsg()
476 {
477 logger.Debug("Entering TestGAMSOptions | testEnumErrMsg");
478
479 globalOpt.ErrMsg = (GAMSOptions.EErrMsg.EndOfCompilerListing);
480 Assert.AreEqual(GAMSOptions.EErrMsg.EndOfCompilerListing, globalOpt.ErrMsg, "expect same options " + GAMSOptions.EErrMsg.EndOfCompilerListing + " set");
481
482 globalOpt.ErrMsg = (GAMSOptions.EErrMsg.FollowingError);
483 Assert.AreEqual(GAMSOptions.EErrMsg.FollowingError, globalOpt.ErrMsg, "expect same options " + GAMSOptions.EErrMsg.FollowingError + " set");
484
485 globalOpt.ErrMsg = (GAMSOptions.EErrMsg.Suppress);
486 Assert.AreEqual(GAMSOptions.EErrMsg.Suppress, globalOpt.ErrMsg, "expect same options " + GAMSOptions.EErrMsg.Suppress + " set");
487
488 logger.Debug("Exiting TestGAMSOptions | testEnumErrMsg");
489 }
490
491 //[Test]
492 //public void TestLookupEnumErrMsg()
493 //{
494 // logger.Debug("Entering TestGAMSOptions | testLookupEnumErrMsg");
495
496 // Assert.AreEqual("Lookup EndOfCompilerListing from EErrMsg", GAMSOptions.EErrMsg.EndOfCompilerListing, GAMSOptions.EErrMsg.lookup(0));
497 // Assert.AreEqual("Lookup FollowingError from EErrMsg", GAMSOptions.EErrMsg.FollowingError, GAMSOptions.EErrMsg.lookup(1));
498 // Assert.AreEqual("Lookup Suppress from EErrMsg", GAMSOptions.EErrMsg.Suppress, GAMSOptions.EErrMsg.lookup(2));
499
500 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumErrMsg");
501 //}
502
503
504 [Test]
505 public void TestEnumExecMode()
506 {
507 logger.Debug("Entering TestGAMSOptions | testEnumExecMode");
508
509 globalOpt.ExecMode = (GAMSOptions.EExecMode.EverythingAllowed);
510 Assert.AreEqual(GAMSOptions.EExecMode.EverythingAllowed, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.EverythingAllowed + " set");
511
512 globalOpt.ExecMode = (GAMSOptions.EExecMode.InteractiveShellsProhibited);
513 Assert.AreEqual(GAMSOptions.EExecMode.InteractiveShellsProhibited, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.InteractiveShellsProhibited + " set");
514
515 globalOpt.ExecMode = (GAMSOptions.EExecMode.CallAndExecuteProhibited);
516 Assert.AreEqual(GAMSOptions.EExecMode.CallAndExecuteProhibited, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.CallAndExecuteProhibited + " set");
517
518 globalOpt.ExecMode = (GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir);
519 Assert.AreEqual(GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir + " set");
520
521 globalOpt.ExecMode = (GAMSOptions.EExecMode.EchoAndPutProhibited);
522 Assert.AreEqual(GAMSOptions.EExecMode.EchoAndPutProhibited, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.EchoAndPutProhibited + " set");
523
524 logger.Debug("Exiting TestGAMSOptions | testEnumExecMode");
525 }
526
527 //[Test]
528 //public void TestLookupEnumExecMode()
529 //{
530 // logger.Debug("Entering TestGAMSOptions | testLookupEnumExecMode");
531
532 // Assert.AreEqual("Lookup EverythingAllowed from EExecMode", GAMSOptions.EExecMode.EverythingAllowed, GAMSOptions.EExecMode.lookup(0));
533 // Assert.AreEqual("Lookup InteractiveShellsProhibited from EExecMode", GAMSOptions.EExecMode.InteractiveShellsProhibited, GAMSOptions.EExecMode.lookup(1));
534 // Assert.AreEqual("Lookup CallAndExecuteProhibited from EExecMode", GAMSOptions.EExecMode.CallAndExecuteProhibited, GAMSOptions.EExecMode.lookup(2));
535 // Assert.AreEqual("Lookup EchoAndPutOnlyToWorkdir from EExecMode", GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir, GAMSOptions.EExecMode.lookup(3));
536 // Assert.AreEqual("Lookup EchoAndPutProhibited from EExecMode", GAMSOptions.EExecMode.EchoAndPutProhibited, GAMSOptions.EExecMode.lookup(4));
537
538 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumExecMode");
539 //}
540
541
542 [Test]
543 public void TestEnumFDOpt()
544 {
545 logger.Debug("Entering TestGAMSOptions | testEnumFDOpt");
546
547 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale);
548 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale + " set");
549
550 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale);
551 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale + " set");
552
553 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale);
554 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale + " set");
555
556 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale);
557 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale + " set");
558
559 globalOpt.FDOpt = (GAMSOptions.EFDOpt.FGHNumericScale);
560 Assert.AreEqual(GAMSOptions.EFDOpt.FGHNumericScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.FGHNumericScale + " set");
561
562 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale);
563 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale + " set");
564
565 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale);
566 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale + " set");
567
568 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale);
569 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale + " set");
570
571 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale);
572 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale + " set");
573
574 globalOpt.FDOpt = (GAMSOptions.EFDOpt.FGHNumericNoScale);
575 Assert.AreEqual(GAMSOptions.EFDOpt.FGHNumericNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.FGHNumericNoScale + " set");
576
577 logger.Debug("Exiting TestGAMSOptions | testEnumFDOpt");
578 }
579
580 //[Test]
581 //public void TestLookupEnumFDOpt()
582 //{
583 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFDOpt");
584
585 // Assert.AreEqual("Lookup GHAnalyticHNumericGradScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale, GAMSOptions.EFDOpt.lookup(0));
586 // Assert.AreEqual("Lookup GHAnalyticHNumericFuncScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale, GAMSOptions.EFDOpt.lookup(1));
587 // Assert.AreEqual("Lookup GAnalyticFHNumericGradScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale, GAMSOptions.EFDOpt.lookup(2));
588 // Assert.AreEqual("Lookup GAnalyticFHNumericFuncScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale, GAMSOptions.EFDOpt.lookup(3));
589 // Assert.AreEqual("Lookup FGHNumericScale from EFDOpt", GAMSOptions.EFDOpt.FGHNumericScale, GAMSOptions.EFDOpt.lookup(4));
590 // Assert.AreEqual("Lookup GHAnalyticHNumericGradNoScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale, GAMSOptions.EFDOpt.lookup(10));
591 // Assert.AreEqual("Lookup GHAnalyticHNumericFuncNoScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale, GAMSOptions.EFDOpt.lookup(11));
592 // Assert.AreEqual("Lookup GAnalyticFHNumericGradNoScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale, GAMSOptions.EFDOpt.lookup(12));
593 // Assert.AreEqual("Lookup GAnalyticFHNumericFuncNoScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale, GAMSOptions.EFDOpt.lookup(13));
594 // Assert.AreEqual("Lookup FGHNumericNoScale from EFDOpt", GAMSOptions.EFDOpt.FGHNumericNoScale, GAMSOptions.EFDOpt.lookup(14));
595
596 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFDOpt");
597 //}
598
599
600 [Test]
601 public void TestEnumFileCase()
602 {
603 logger.Debug("Entering TestGAMSOptions | testEnumFileCase");
604
605 globalOpt.FileCase = (GAMSOptions.EFileCase.DefaultCase);
606 Assert.AreEqual(GAMSOptions.EFileCase.DefaultCase, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.DefaultCase + " set");
607
608 globalOpt.FileCase = (GAMSOptions.EFileCase.UpperCase);
609 Assert.AreEqual(GAMSOptions.EFileCase.UpperCase, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.UpperCase + " set");
610
611 globalOpt.FileCase = (GAMSOptions.EFileCase.LowerCase);
612 Assert.AreEqual(GAMSOptions.EFileCase.LowerCase, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.LowerCase + " set");
613
614 globalOpt.FileCase = (GAMSOptions.EFileCase.UpperCaseFileOnly);
615 Assert.AreEqual(GAMSOptions.EFileCase.UpperCaseFileOnly, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.UpperCaseFileOnly + " set");
616
617 globalOpt.FileCase = (GAMSOptions.EFileCase.LowerCaseFileOnly);
618 Assert.AreEqual(GAMSOptions.EFileCase.LowerCaseFileOnly, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.LowerCaseFileOnly + " set");
619
620 logger.Debug("Exiting TestGAMSOptions | testEnumFileCase");
621 }
622
623 //[Test]
624 //public void TestLookupEnumFileCase()
625 //{
626 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFileCase");
627
628 // Assert.AreEqual("Lookup DefaultCase from EFileCase", GAMSOptions.EFileCase.DefaultCase, GAMSOptions.EFileCase.lookup(0));
629 // Assert.AreEqual("Lookup UpperCase from EFileCase", GAMSOptions.EFileCase.UpperCase, GAMSOptions.EFileCase.lookup(1));
630 // Assert.AreEqual("Lookup LowerCase from EFileCase", GAMSOptions.EFileCase.LowerCase, GAMSOptions.EFileCase.lookup(2));
631 // Assert.AreEqual("Lookup UpperCaseFileOnly from EFileCase", GAMSOptions.EFileCase.UpperCaseFileOnly, GAMSOptions.EFileCase.lookup(3));
632 // Assert.AreEqual("Lookup LowerCaseFileOnly from EFileCase", GAMSOptions.EFileCase.LowerCaseFileOnly, GAMSOptions.EFileCase.lookup(4));
633
634 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFileCase");
635 //}
636
637
638 [Test]
639 public void TestEnumFiltered()
640 {
641 logger.Debug("Entering TestGAMSOptions | testEnumFiltered");
642
643 globalOpt.Filtered = (GAMSOptions.EFiltered.OffFiltered);
644 Assert.AreEqual(GAMSOptions.EFiltered.OffFiltered, globalOpt.Filtered, "expect same options " + GAMSOptions.EFiltered.OffFiltered + " set");
645
646 globalOpt.Filtered = (GAMSOptions.EFiltered.OnFiltered);
647 Assert.AreEqual(GAMSOptions.EFiltered.OnFiltered, globalOpt.Filtered, "expect same options " + GAMSOptions.EFiltered.OnFiltered + " set");
648
649 logger.Debug("Exiting TestGAMSOptions | testEnumFiltered");
650 }
651
652 //[Test]
653 //public void TestLookupEnumFiltered()
654 //{
655 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFiltered");
656
657 // Assert.AreEqual("Lookup off from EFiltered", GAMSOptions.EFiltered.OffFiltered, GAMSOptions.EFiltered.lookup("off"));
658 // Assert.AreEqual("Lookup on from EFiltered", GAMSOptions.EFiltered.OnFiltered, GAMSOptions.EFiltered.lookup("on"));
659
660 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFiltered");
661 //}
662
663
664 [Test]
665 public void TestEnumForceWork()
666 {
667 logger.Debug("Entering TestGAMSOptions | testEnumForceWork");
668
669 globalOpt.ForceWork = (GAMSOptions.EForceWork.NoTranslation);
670 Assert.AreEqual(GAMSOptions.EForceWork.NoTranslation, globalOpt.ForceWork, "expect same options " + GAMSOptions.EForceWork.NoTranslation + " set");
671
672 globalOpt.ForceWork = (GAMSOptions.EForceWork.TryTranslation);
673 Assert.AreEqual(GAMSOptions.EForceWork.TryTranslation, globalOpt.ForceWork, "expect same options " + GAMSOptions.EForceWork.TryTranslation + " set");
674
675 logger.Debug("Exiting TestGAMSOptions | testEnumForceWork");
676 }
677
678 //[Test]
679 //public void TestLookupEnumForceWork()
680 //{
681 // logger.Debug("Entering TestGAMSOptions | testLookupEnumForceWork");
682
683 // Assert.AreEqual("Lookup NoTranslation from EForceWork", GAMSOptions.EForceWork.NoTranslation, GAMSOptions.EForceWork.lookup(0));
684 // Assert.AreEqual("Lookup TryTranslation from EForceWork", GAMSOptions.EForceWork.TryTranslation, GAMSOptions.EForceWork.lookup(1));
685
686 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumForceWork");
687 //}
688
689
690 [Test]
691 public void TestEnumFreeEmbeddedPython()
692 {
693 logger.Debug("Entering TestGAMSOptions | testEnumFreeEmbeddedPython");
694
695 globalOpt.FreeEmbeddedPython = (GAMSOptions.EFreeEmbeddedPython.Off);
696 Assert.AreEqual(GAMSOptions.EFreeEmbeddedPython.Off, globalOpt.FreeEmbeddedPython, "expect same options " + GAMSOptions.EFreeEmbeddedPython.Off + " set");
697
698 globalOpt.FreeEmbeddedPython = (GAMSOptions.EFreeEmbeddedPython.On);
699 Assert.AreEqual(GAMSOptions.EFreeEmbeddedPython.On, globalOpt.FreeEmbeddedPython, "expect same options " + GAMSOptions.EFreeEmbeddedPython.On + " set");
700
701 logger.Debug("Exiting TestGAMSOptions | testEnumFreeEmbeddedPython");
702 }
703
704 //[Test]
705 //public void TestLookupEnumFreeEmbeddedPython()
706 //{
707 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFreeEmbeddedPython");
708
709 // Assert.AreEqual("Lookup Off from EFreeEmbeddedPython", GAMSOptions.EFreeEmbeddedPython.Off, GAMSOptions.EFreeEmbeddedPython.lookup(0));
710 // Assert.AreEqual("Lookup On from EFreeEmbeddedPython", GAMSOptions.EFreeEmbeddedPython.On, GAMSOptions.EFreeEmbeddedPython.lookup(1));
711
712 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFreeEmbeddedPython");
713 //}
714
715
716 [Test]
717 public void TestEnumgdxCompress()
718 {
719 logger.Debug("Entering TestGAMSOptions | testEnumgdxCompress");
720
721 globalOpt.gdxCompress = (GAMSOptions.EgdxCompress.DoNotCompressGDX);
722 Assert.AreEqual(GAMSOptions.EgdxCompress.DoNotCompressGDX, globalOpt.gdxCompress, "expect same options " + GAMSOptions.EgdxCompress.DoNotCompressGDX + " set");
723
724 globalOpt.gdxCompress = (GAMSOptions.EgdxCompress.CompressGDX);
725 Assert.AreEqual(GAMSOptions.EgdxCompress.CompressGDX, globalOpt.gdxCompress, "expect same options " + GAMSOptions.EgdxCompress.CompressGDX + " set");
726
727 logger.Debug("Exiting TestGAMSOptions | testEnumgdxCompress");
728 }
729
730 //[Test]
731 //public void TestLookupEnumgdxCompress()
732 //{
733 // logger.Debug("Entering TestGAMSOptions | testLookupEnumgdxCompress");
734
735 // Assert.AreEqual("Lookup DoNotCompressGDX from EgdxCompress", GAMSOptions.EgdxCompress.DoNotCompressGDX, GAMSOptions.EgdxCompress.lookup(0));
736 // Assert.AreEqual("Lookup CompressGDX from EgdxCompress", GAMSOptions.EgdxCompress.CompressGDX, GAMSOptions.EgdxCompress.lookup(1));
737
738 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumgdxCompress");
739 //}
740
741
742 [Test]
743 public void TestEnumgdxConvert()
744 {
745 logger.Debug("Entering TestGAMSOptions | testEnumgdxConvert");
746
747 globalOpt.gdxConvert = (GAMSOptions.EgdxConvert.Version5);
748 Assert.AreEqual(GAMSOptions.EgdxConvert.Version5, globalOpt.gdxConvert, "expect same options " + GAMSOptions.EgdxConvert.Version5 + " set");
749
750 globalOpt.gdxConvert = (GAMSOptions.EgdxConvert.Version6);
751 Assert.AreEqual(GAMSOptions.EgdxConvert.Version6, globalOpt.gdxConvert, "expect same options " + GAMSOptions.EgdxConvert.Version6 + " set");
752
753 globalOpt.gdxConvert = (GAMSOptions.EgdxConvert.Version7);
754 Assert.AreEqual(GAMSOptions.EgdxConvert.Version7, globalOpt.gdxConvert, "expect same options " + GAMSOptions.EgdxConvert.Version7 + " set");
755
756 logger.Debug("Exiting TestGAMSOptions | testEnumgdxConvert");
757 }
758
759 //[Test]
760 //public void TestLookupEnumgdxConvert()
761 //{
762 // logger.Debug("Entering TestGAMSOptions | testLookupEnumgdxConvert");
763
764 // Assert.AreEqual("Lookup v5 from EgdxConvert", GAMSOptions.EgdxConvert.Version5, GAMSOptions.EgdxConvert.lookup("v5"));
765 // Assert.AreEqual("Lookup v6 from EgdxConvert", GAMSOptions.EgdxConvert.Version6, GAMSOptions.EgdxConvert.lookup("v6"));
766 // Assert.AreEqual("Lookup v7 from EgdxConvert", GAMSOptions.EgdxConvert.Version7, GAMSOptions.EgdxConvert.lookup("v7"));
767
768 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumgdxConvert");
769 //}
770
771
772 [Test]
773 public void TestEnumgdxUels()
774 {
775 logger.Debug("Entering TestGAMSOptions | testEnumgdxUels");
776
777 globalOpt.gdxUels = (GAMSOptions.EgdxUels.squeezed);
778 Assert.AreEqual(GAMSOptions.EgdxUels.squeezed, globalOpt.gdxUels, "expect same options " + GAMSOptions.EgdxUels.squeezed + " set");
779
780 globalOpt.gdxUels = (GAMSOptions.EgdxUels.full);
781 Assert.AreEqual(GAMSOptions.EgdxUels.full, globalOpt.gdxUels, "expect same options " + GAMSOptions.EgdxUels.full + " set");
782
783 logger.Debug("Exiting TestGAMSOptions | testEnumgdxUels");
784 }
785
786 //[Test]
787 //public void TestLookupEnumgdxUels()
788 //{
789 // logger.Debug("Entering TestGAMSOptions | testLookupEnumgdxUels");
790
791 // Assert.AreEqual("Lookup Squeezed from EgdxUels", GAMSOptions.EgdxUels.squeezed, GAMSOptions.EgdxUels.lookup("Squeezed"));
792 // Assert.AreEqual("Lookup Full from EgdxUels", GAMSOptions.EgdxUels.full, GAMSOptions.EgdxUels.lookup("Full"));
793
794 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumgdxUels");
795 //}
796
797
798 [Test]
799 public void TestEnumHoldFixed()
800 {
801 logger.Debug("Entering TestGAMSOptions | testEnumHoldFixed");
802
803 globalOpt.HoldFixed = (GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants);
804 Assert.AreEqual(GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants, globalOpt.HoldFixed, "expect same options " + GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants + " set");
805
806 globalOpt.HoldFixed = (GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants);
807 Assert.AreEqual(GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants, globalOpt.HoldFixed, "expect same options " + GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants + " set");
808
809 logger.Debug("Exiting TestGAMSOptions | testEnumHoldFixed");
810 }
811
812 //[Test]
813 //public void TestLookupEnumHoldFixed()
814 //{
815 // logger.Debug("Entering TestGAMSOptions | testLookupEnumHoldFixed");
816
817 // Assert.AreEqual("Lookup FixedVarsNotTreatedAsConstants from EHoldFixed", GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants, GAMSOptions.EHoldFixed.lookup(0));
818 // Assert.AreEqual("Lookup FixedVarsTreatedAsConstants from EHoldFixed", GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants, GAMSOptions.EHoldFixed.lookup(1));
819
820 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumHoldFixed");
821 //}
822
823
824 [Test]
825 public void TestEnumHoldFixedAsync()
826 {
827 logger.Debug("Entering TestGAMSOptions | testEnumHoldFixedAsync");
828
829 globalOpt.HoldFixedAsync = (GAMSOptions.EHoldFixedAsync.Off);
830 Assert.AreEqual(GAMSOptions.EHoldFixedAsync.Off, globalOpt.HoldFixedAsync, "expect same options " + GAMSOptions.EHoldFixedAsync.Off + " set");
831
832 globalOpt.HoldFixedAsync = (GAMSOptions.EHoldFixedAsync.On);
833 Assert.AreEqual(GAMSOptions.EHoldFixedAsync.On, globalOpt.HoldFixedAsync, "expect same options " + GAMSOptions.EHoldFixedAsync.On + " set");
834
835 logger.Debug("Exiting TestGAMSOptions | testEnumHoldFixedAsync");
836 }
837
838 //[Test]
839 //public void TestLookupEnumHoldFixedAsync()
840 //{
841 // logger.Debug("Entering TestGAMSOptions | testLookupEnumHoldFixedAsync");
842
843 // Assert.AreEqual("Lookup Off from EHoldFixedAsync", GAMSOptions.EHoldFixedAsync.Off, GAMSOptions.EHoldFixedAsync.lookup(0));
844 // Assert.AreEqual("Lookup On from EHoldFixedAsync", GAMSOptions.EHoldFixedAsync.On, GAMSOptions.EHoldFixedAsync.lookup(1));
845
846 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumHoldFixedAsync");
847 //}
848
849
850 [Test]
851 public void TestEnumInteractiveSolver()
852 {
853 logger.Debug("Entering TestGAMSOptions | testEnumInteractiveSolver");
854
855 globalOpt.InteractiveSolver = (GAMSOptions.EInteractiveSolver.NoInteraction);
856 Assert.AreEqual(GAMSOptions.EInteractiveSolver.NoInteraction, globalOpt.InteractiveSolver, "expect same options " + GAMSOptions.EInteractiveSolver.NoInteraction + " set");
857
858 globalOpt.InteractiveSolver = (GAMSOptions.EInteractiveSolver.AllowInteraction);
859 Assert.AreEqual(GAMSOptions.EInteractiveSolver.AllowInteraction, globalOpt.InteractiveSolver, "expect same options " + GAMSOptions.EInteractiveSolver.AllowInteraction + " set");
860
861 logger.Debug("Exiting TestGAMSOptions | testEnumInteractiveSolver");
862 }
863
864 //[Test]
865 //public void TestLookupEnumInteractiveSolver()
866 //{
867 // logger.Debug("Entering TestGAMSOptions | testLookupEnumInteractiveSolver");
868
869 // Assert.AreEqual("Lookup NoInteraction from EInteractiveSolver", GAMSOptions.EInteractiveSolver.NoInteraction, GAMSOptions.EInteractiveSolver.lookup(0));
870 // Assert.AreEqual("Lookup AllowInteraction from EInteractiveSolver", GAMSOptions.EInteractiveSolver.AllowInteraction, GAMSOptions.EInteractiveSolver.lookup(1));
871
872 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumInteractiveSolver");
873 //}
874
875
876 [Test]
877 public void TestEnumIntVarUp()
878 {
879 logger.Debug("Entering TestGAMSOptions | testEnumIntVarUp");
880
881 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.INF);
882 Assert.AreEqual(GAMSOptions.EIntVarUp.INF, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.INF + " set");
883
884 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.Pass100ToSolver);
885 Assert.AreEqual(GAMSOptions.EIntVarUp.Pass100ToSolver, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.Pass100ToSolver + " set");
886
887 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.INFandLog);
888 Assert.AreEqual(GAMSOptions.EIntVarUp.INFandLog, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.INFandLog + " set");
889
890 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.Pass100ToSolverAndError);
891 Assert.AreEqual(GAMSOptions.EIntVarUp.Pass100ToSolverAndError, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.Pass100ToSolverAndError + " set");
892
893 logger.Debug("Exiting TestGAMSOptions | testEnumIntVarUp");
894 }
895
896 //[Test]
897 //public void TestLookupEnumIntVarUp()
898 //{
899 // logger.Debug("Entering TestGAMSOptions | testLookupEnumIntVarUp");
900
901 // Assert.AreEqual("Lookup INF from EIntVarUp", GAMSOptions.EIntVarUp.INF, GAMSOptions.EIntVarUp.lookup(0));
902 // Assert.AreEqual("Lookup Pass100ToSolver from EIntVarUp", GAMSOptions.EIntVarUp.Pass100ToSolver, GAMSOptions.EIntVarUp.lookup(1));
903 // Assert.AreEqual("Lookup INFandLog from EIntVarUp", GAMSOptions.EIntVarUp.INFandLog, GAMSOptions.EIntVarUp.lookup(2));
904 // Assert.AreEqual("Lookup Pass100ToSolverAndError from EIntVarUp", GAMSOptions.EIntVarUp.Pass100ToSolverAndError, GAMSOptions.EIntVarUp.lookup(3));
905
906 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumIntVarUp");
907 //}
908
909
910 [Test]
911 public void TestEnumKeep()
912 {
913 logger.Debug("Entering TestGAMSOptions | testEnumKeep");
914
915 globalOpt.Keep = (GAMSOptions.EKeep.DeleteProcDir);
916 Assert.AreEqual(GAMSOptions.EKeep.DeleteProcDir, globalOpt.Keep, "expect same options " + GAMSOptions.EKeep.DeleteProcDir + " set");
917
918 globalOpt.Keep = (GAMSOptions.EKeep.KeepProcDir);
919 Assert.AreEqual(GAMSOptions.EKeep.KeepProcDir, globalOpt.Keep, "expect same options " + GAMSOptions.EKeep.KeepProcDir + " set");
920
921 logger.Debug("Exiting TestGAMSOptions | testEnumKeep");
922 }
923
924 //[Test]
925 //public void TestLookupEnumKeep()
926 //{
927 // logger.Debug("Entering TestGAMSOptions | testLookupEnumKeep");
928
929 // Assert.AreEqual("Lookup DeleteProcDir from EKeep", GAMSOptions.EKeep.DeleteProcDir, GAMSOptions.EKeep.lookup(0));
930 // Assert.AreEqual("Lookup KeepProcDir from EKeep", GAMSOptions.EKeep.KeepProcDir, GAMSOptions.EKeep.lookup(1));
931
932 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumKeep");
933 //}
934
935
936 [Test]
937 public void TestEnumListing()
938 {
939 logger.Debug("Entering TestGAMSOptions | testEnumListing");
940
941 globalOpt.Listing = (GAMSOptions.EListing.OffListing);
942 Assert.AreEqual(GAMSOptions.EListing.OffListing, globalOpt.Listing, "expect same options " + GAMSOptions.EListing.OffListing + " set");
943
944 globalOpt.Listing = (GAMSOptions.EListing.OnListing);
945 Assert.AreEqual(GAMSOptions.EListing.OnListing, globalOpt.Listing, "expect same options " + GAMSOptions.EListing.OnListing + " set");
946
947 logger.Debug("Exiting TestGAMSOptions | testEnumListing");
948 }
949
950 //[Test]
951 //public void TestLookupEnumListing()
952 //{
953 // logger.Debug("Entering TestGAMSOptions | testLookupEnumListing");
954
955 // Assert.AreEqual("Lookup off from EListing", GAMSOptions.EListing.OffListing, GAMSOptions.EListing.lookup("off"));
956 // Assert.AreEqual("Lookup on from EListing", GAMSOptions.EListing.OnListing, GAMSOptions.EListing.lookup("on"));
957
958 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumListing");
959 //}
960
961
962 [Test]
963 public void TestEnumLogLine()
964 {
965 logger.Debug("Entering TestGAMSOptions | testEnumLogLine");
966
967 globalOpt.LogLine = (GAMSOptions.ELogLine.NoTracing);
968 Assert.AreEqual(GAMSOptions.ELogLine.NoTracing, globalOpt.LogLine, "expect same options " + GAMSOptions.ELogLine.NoTracing + " set");
969
970 globalOpt.LogLine = (GAMSOptions.ELogLine.MinimumTracing);
971 Assert.AreEqual(GAMSOptions.ELogLine.MinimumTracing, globalOpt.LogLine, "expect same options " + GAMSOptions.ELogLine.MinimumTracing + " set");
972
973 globalOpt.LogLine = (GAMSOptions.ELogLine.Automatic);
974 Assert.AreEqual(GAMSOptions.ELogLine.Automatic, globalOpt.LogLine, "expect same options " + GAMSOptions.ELogLine.Automatic + " set");
975
976 logger.Debug("Exiting TestGAMSOptions | testEnumLogLine");
977 }
978
979 //[Test]
980 //public void TestLookupEnumLogLine()
981 //{
982 // logger.Debug("Entering TestGAMSOptions | testLookupEnumLogLine");
983
984 // Assert.AreEqual("Lookup NoTracing from ELogLine", GAMSOptions.ELogLine.NoTracing, GAMSOptions.ELogLine.lookup(0));
985 // Assert.AreEqual("Lookup MinimumTracing from ELogLine", GAMSOptions.ELogLine.MinimumTracing, GAMSOptions.ELogLine.lookup(1));
986 // Assert.AreEqual("Lookup Automatic from ELogLine", GAMSOptions.ELogLine.Automatic, GAMSOptions.ELogLine.lookup(2));
987
988 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumLogLine");
989 //}
990
991
992 [Test]
993 public void TestEnumLstTitleLeftAligned()
994 {
995 logger.Debug("Entering TestGAMSOptions | testEnumLstTitleLeftAligned");
996
997 globalOpt.LstTitleLeftAligned = (GAMSOptions.ELstTitleLeftAligned.Off);
998 Assert.AreEqual(GAMSOptions.ELstTitleLeftAligned.Off, globalOpt.LstTitleLeftAligned, "expect same options " + GAMSOptions.ELstTitleLeftAligned.Off + " set");
999
1000 globalOpt.LstTitleLeftAligned = (GAMSOptions.ELstTitleLeftAligned.On);
1001 Assert.AreEqual(GAMSOptions.ELstTitleLeftAligned.On, globalOpt.LstTitleLeftAligned, "expect same options " + GAMSOptions.ELstTitleLeftAligned.On + " set");
1002
1003 logger.Debug("Exiting TestGAMSOptions | testEnumLstTitleLeftAligned");
1004 }
1005
1006 //[Test]
1007 //public void TestLookupEnumLstTitleLeftAligned()
1008 //{
1009 // logger.Debug("Entering TestGAMSOptions | testLookupEnumLstTitleLeftAligned");
1010
1011 // Assert.AreEqual("Lookup Off from ELstTitleLeftAligned", GAMSOptions.ELstTitleLeftAligned.Off, GAMSOptions.ELstTitleLeftAligned.lookup(0));
1012 // Assert.AreEqual("Lookup On from ELstTitleLeftAligned", GAMSOptions.ELstTitleLeftAligned.On, GAMSOptions.ELstTitleLeftAligned.lookup(1));
1013
1014 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumLstTitleLeftAligned");
1015 //}
1016
1017
1018 [Test]
1019 public void TestEnumNoNewVarEqu()
1020 {
1021 logger.Debug("Entering TestGAMSOptions | testEnumNoNewVarEqu");
1022
1023 globalOpt.NoNewVarEqu = (GAMSOptions.ENoNewVarEqu.AllowNewVarEqu);
1024 Assert.AreEqual(GAMSOptions.ENoNewVarEqu.AllowNewVarEqu, globalOpt.NoNewVarEqu, "expect same options " + GAMSOptions.ENoNewVarEqu.AllowNewVarEqu + " set");
1025
1026 globalOpt.NoNewVarEqu = (GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu);
1027 Assert.AreEqual(GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu, globalOpt.NoNewVarEqu, "expect same options " + GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu + " set");
1028
1029 logger.Debug("Exiting TestGAMSOptions | testEnumNoNewVarEqu");
1030 }
1031
1032 //[Test]
1033 //public void TestLookupEnumNoNewVarEqu()
1034 //{
1035 // logger.Debug("Entering TestGAMSOptions | testLookupEnumNoNewVarEqu");
1036
1037 // Assert.AreEqual("Lookup AllowNewVarEqu from ENoNewVarEqu", GAMSOptions.ENoNewVarEqu.AllowNewVarEqu, GAMSOptions.ENoNewVarEqu.lookup(0));
1038 // Assert.AreEqual("Lookup DoNotAllowNewVarEqu from ENoNewVarEqu", GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu, GAMSOptions.ENoNewVarEqu.lookup(1));
1039
1040 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumNoNewVarEqu");
1041 //}
1042
1043
1044 [Test]
1045 public void TestEnumOn115()
1046 {
1047 logger.Debug("Entering TestGAMSOptions | testEnumOn115");
1048
1049 globalOpt.On115 = (GAMSOptions.EOn115.NoMessages);
1050 Assert.AreEqual(GAMSOptions.EOn115.NoMessages, globalOpt.On115, "expect same options " + GAMSOptions.EOn115.NoMessages + " set");
1051
1052 globalOpt.On115 = (GAMSOptions.EOn115.IssueMessages);
1053 Assert.AreEqual(GAMSOptions.EOn115.IssueMessages, globalOpt.On115, "expect same options " + GAMSOptions.EOn115.IssueMessages + " set");
1054
1055 logger.Debug("Exiting TestGAMSOptions | testEnumOn115");
1056 }
1057
1058 //[Test]
1059 //public void TestLookupEnumOn115()
1060 //{
1061 // logger.Debug("Entering TestGAMSOptions | testLookupEnumOn115");
1062
1063 // Assert.AreEqual("Lookup NoMessages from EOn115", GAMSOptions.EOn115.NoMessages, GAMSOptions.EOn115.lookup(0));
1064 // Assert.AreEqual("Lookup IssueMessages from EOn115", GAMSOptions.EOn115.IssueMessages, GAMSOptions.EOn115.lookup(1));
1065
1066 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumOn115");
1067 //}
1068
1069
1070 [Test]
1071 public void TestEnumPageContr()
1072 {
1073 logger.Debug("Entering TestGAMSOptions | testEnumPageContr");
1074
1075 globalOpt.PageContr = (GAMSOptions.EPageContr.NoPageContrWithPadding);
1076 Assert.AreEqual(GAMSOptions.EPageContr.NoPageContrWithPadding, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.NoPageContrWithPadding + " set");
1077
1078 globalOpt.PageContr = (GAMSOptions.EPageContr.FortranStyle);
1079 Assert.AreEqual(GAMSOptions.EPageContr.FortranStyle, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.FortranStyle + " set");
1080
1081 globalOpt.PageContr = (GAMSOptions.EPageContr.NoPageContrNoPadding);
1082 Assert.AreEqual(GAMSOptions.EPageContr.NoPageContrNoPadding, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.NoPageContrNoPadding + " set");
1083
1084 globalOpt.PageContr = (GAMSOptions.EPageContr.FormfeedCharNewPage);
1085 Assert.AreEqual(GAMSOptions.EPageContr.FormfeedCharNewPage, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.FormfeedCharNewPage + " set");
1086
1087 logger.Debug("Exiting TestGAMSOptions | testEnumPageContr");
1088 }
1089
1090 //[Test]
1091 //public void TestLookupEnumPageContr()
1092 //{
1093 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPageContr");
1094
1095 // Assert.AreEqual("Lookup NoPageContrWithPadding from EPageContr", GAMSOptions.EPageContr.NoPageContrWithPadding, GAMSOptions.EPageContr.lookup(0));
1096 // Assert.AreEqual("Lookup FortranStyle from EPageContr", GAMSOptions.EPageContr.FortranStyle, GAMSOptions.EPageContr.lookup(1));
1097 // Assert.AreEqual("Lookup NoPageContrNoPadding from EPageContr", GAMSOptions.EPageContr.NoPageContrNoPadding, GAMSOptions.EPageContr.lookup(2));
1098 // Assert.AreEqual("Lookup FormfeedCharNewPage from EPageContr", GAMSOptions.EPageContr.FormfeedCharNewPage, GAMSOptions.EPageContr.lookup(3));
1099
1100 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPageContr");
1101 //}
1102
1103
1104 [Test]
1105 public void TestEnumPrefixLoadPath()
1106 {
1107 logger.Debug("Entering TestGAMSOptions | testEnumPrefixLoadPath");
1108
1109 globalOpt.PrefixLoadPath = (GAMSOptions.EPrefixLoadPath.Off);
1110 Assert.AreEqual(GAMSOptions.EPrefixLoadPath.Off, globalOpt.PrefixLoadPath, "expect same options " + GAMSOptions.EPrefixLoadPath.Off + " set");
1111
1112 globalOpt.PrefixLoadPath = (GAMSOptions.EPrefixLoadPath.On);
1113 Assert.AreEqual(GAMSOptions.EPrefixLoadPath.On, globalOpt.PrefixLoadPath, "expect same options " + GAMSOptions.EPrefixLoadPath.On + " set");
1114
1115 logger.Debug("Exiting TestGAMSOptions | testEnumPrefixLoadPath");
1116 }
1117
1118 //[Test]
1119 //public void TestLookupEnumPrefixLoadPath()
1120 //{
1121 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPrefixLoadPath");
1122
1123 // Assert.AreEqual("Lookup Off from EPrefixLoadPath", GAMSOptions.EPrefixLoadPath.Off, GAMSOptions.EPrefixLoadPath.lookup(0));
1124 // Assert.AreEqual("Lookup On from EPrefixLoadPath", GAMSOptions.EPrefixLoadPath.On, GAMSOptions.EPrefixLoadPath.lookup(1));
1125
1126 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPrefixLoadPath");
1127 //}
1128
1129
1130 [Test]
1131 public void TestEnumPreviousWork()
1132 {
1133 logger.Debug("Entering TestGAMSOptions | testEnumPreviousWork");
1134
1135 globalOpt.PreviousWork = (GAMSOptions.EPreviousWork.Off);
1136 Assert.AreEqual(GAMSOptions.EPreviousWork.Off, globalOpt.PreviousWork, "expect same options " + GAMSOptions.EPreviousWork.Off + " set");
1137
1138 globalOpt.PreviousWork = (GAMSOptions.EPreviousWork.On);
1139 Assert.AreEqual(GAMSOptions.EPreviousWork.On, globalOpt.PreviousWork, "expect same options " + GAMSOptions.EPreviousWork.On + " set");
1140
1141 logger.Debug("Exiting TestGAMSOptions | testEnumPreviousWork");
1142 }
1143
1144 //[Test]
1145 //public void TestLookupEnumPreviousWork()
1146 //{
1147 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPreviousWork");
1148
1149 // Assert.AreEqual("Lookup Off from EPreviousWork", GAMSOptions.EPreviousWork.Off, GAMSOptions.EPreviousWork.lookup(0));
1150 // Assert.AreEqual("Lookup On from EPreviousWork", GAMSOptions.EPreviousWork.On, GAMSOptions.EPreviousWork.lookup(1));
1151
1152 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPreviousWork");
1153 //}
1154
1155
1156 [Test]
1157 public void TestEnumProcTreeMemMonitor()
1158 {
1159 logger.Debug("Entering TestGAMSOptions | testEnumProcTreeMemMonitor");
1160
1161 globalOpt.ProcTreeMemMonitor = (GAMSOptions.EProcTreeMemMonitor.Off);
1162 Assert.AreEqual(GAMSOptions.EProcTreeMemMonitor.Off, globalOpt.ProcTreeMemMonitor, "expect same options " + GAMSOptions.EProcTreeMemMonitor.Off + " set");
1163
1164 globalOpt.ProcTreeMemMonitor = (GAMSOptions.EProcTreeMemMonitor.On);
1165 Assert.AreEqual(GAMSOptions.EProcTreeMemMonitor.On, globalOpt.ProcTreeMemMonitor, "expect same options " + GAMSOptions.EProcTreeMemMonitor.On + " set");
1166
1167 logger.Debug("Exiting TestGAMSOptions | testEnumProcTreeMemMonitor");
1168 }
1169
1170 //[Test]
1171 //public void TestLookupEnumProcTreeMemMonitor()
1172 //{
1173 // logger.Debug("Entering TestGAMSOptions | testLookupEnumProcTreeMemMonitor");
1174
1175 // Assert.AreEqual("Lookup Off from EProcTreeMemMonitor", GAMSOptions.EProcTreeMemMonitor.Off, GAMSOptions.EProcTreeMemMonitor.lookup(0));
1176 // Assert.AreEqual("Lookup On from EProcTreeMemMonitor", GAMSOptions.EProcTreeMemMonitor.On, GAMSOptions.EProcTreeMemMonitor.lookup(1));
1177
1178 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumProcTreeMemMonitor");
1179 //}
1180
1181
1182 [Test]
1183 public void TestEnumPutNR()
1184 {
1185 logger.Debug("Entering TestGAMSOptions | testEnumPutNR");
1186
1187 globalOpt.PutNR = (GAMSOptions.EPutNR.ForE);
1188 Assert.AreEqual(GAMSOptions.EPutNR.ForE, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.ForE + " set");
1189
1190 globalOpt.PutNR = (GAMSOptions.EPutNR.Rounded);
1191 Assert.AreEqual(GAMSOptions.EPutNR.Rounded, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.Rounded + " set");
1192
1193 globalOpt.PutNR = (GAMSOptions.EPutNR.Scientific);
1194 Assert.AreEqual(GAMSOptions.EPutNR.Scientific, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.Scientific + " set");
1195
1196 globalOpt.PutNR = (GAMSOptions.EPutNR.RoundedFloatingDec);
1197 Assert.AreEqual(GAMSOptions.EPutNR.RoundedFloatingDec, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.RoundedFloatingDec + " set");
1198
1199 globalOpt.PutNR = (GAMSOptions.EPutNR.ForEFloatingDec);
1200 Assert.AreEqual(GAMSOptions.EPutNR.ForEFloatingDec, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.ForEFloatingDec + " set");
1201
1202 logger.Debug("Exiting TestGAMSOptions | testEnumPutNR");
1203 }
1204
1205 //[Test]
1206 //public void TestLookupEnumPutNR()
1207 //{
1208 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPutNR");
1209
1210 // Assert.AreEqual("Lookup ForE from EPutNR", GAMSOptions.EPutNR.ForE, GAMSOptions.EPutNR.lookup(0));
1211 // Assert.AreEqual("Lookup Rounded from EPutNR", GAMSOptions.EPutNR.Rounded, GAMSOptions.EPutNR.lookup(1));
1212 // Assert.AreEqual("Lookup Scientific from EPutNR", GAMSOptions.EPutNR.Scientific, GAMSOptions.EPutNR.lookup(2));
1213 // Assert.AreEqual("Lookup RoundedFloatingDec from EPutNR", GAMSOptions.EPutNR.RoundedFloatingDec, GAMSOptions.EPutNR.lookup(3));
1214 // Assert.AreEqual("Lookup ForEFloatingDec from EPutNR", GAMSOptions.EPutNR.ForEFloatingDec, GAMSOptions.EPutNR.lookup(4));
1215
1216 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPutNR");
1217 //}
1218
1219 [Test]
1220 public void TestEnumReferenceLineNo()
1221 {
1222 logger.Debug("Entering TestGAMSOptions | testEnumReferenceLineNo");
1223
1224 globalOpt.ReferenceLineNo = (GAMSOptions.EReferenceLineNo.ActualLineNumber);
1225 Assert.AreEqual(GAMSOptions.EReferenceLineNo.ActualLineNumber, globalOpt.ReferenceLineNo, "expect same options " + GAMSOptions.EReferenceLineNo.ActualLineNumber + " set");
1226
1227 globalOpt.ReferenceLineNo = (GAMSOptions.EReferenceLineNo.StatementStart);
1228 Assert.AreEqual(GAMSOptions.EReferenceLineNo.StatementStart, globalOpt.ReferenceLineNo, "expect same options " + GAMSOptions.EReferenceLineNo.StatementStart + " set");
1229
1230 logger.Debug("Exiting TestGAMSOptions | testEnumReferenceLineNo");
1231 }
1232
1233 //[Test]
1234 //public void TestLookupEnumReferenceLineNo()
1235 //{
1236 // logger.Debug("Entering TestGAMSOptions | testLookupEnumReferenceLineNo");
1237
1238 // Assert.AreEqual("Lookup actual from EReferenceLineNo", GAMSOptions.EReferenceLineNo.ActualLineNumber, GAMSOptions.EReferenceLineNo.lookup("actual"));
1239 // Assert.AreEqual("Lookup start from EReferenceLineNo", GAMSOptions.EReferenceLineNo.StatementStart, GAMSOptions.EReferenceLineNo.lookup("start"));
1240
1241 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumReferenceLineNo");
1242 //}
1243
1244
1245 [Test]
1246 public void TestEnumSavePoint()
1247 {
1248 logger.Debug("Entering TestGAMSOptions | testEnumSavePoint");
1249
1250 globalOpt.SavePoint = (GAMSOptions.ESavePoint.NoPointFile);
1251 Assert.AreEqual(GAMSOptions.ESavePoint.NoPointFile, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.NoPointFile + " set");
1252
1253 globalOpt.SavePoint = (GAMSOptions.ESavePoint.LastSolvePointFile);
1254 Assert.AreEqual(GAMSOptions.ESavePoint.LastSolvePointFile, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.LastSolvePointFile + " set");
1255
1256 globalOpt.SavePoint = (GAMSOptions.ESavePoint.EverySolvePointFile);
1257 Assert.AreEqual(GAMSOptions.ESavePoint.EverySolvePointFile, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.EverySolvePointFile + " set");
1258
1259 globalOpt.SavePoint = (GAMSOptions.ESavePoint.LastSolvePointFileScrDir);
1260 Assert.AreEqual(GAMSOptions.ESavePoint.LastSolvePointFileScrDir, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.LastSolvePointFileScrDir + " set");
1261
1262 globalOpt.SavePoint = (GAMSOptions.ESavePoint.EverySolvePointFileScrDir);
1263 Assert.AreEqual(GAMSOptions.ESavePoint.EverySolvePointFileScrDir, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.EverySolvePointFileScrDir + " set");
1264
1265 logger.Debug("Exiting TestGAMSOptions | testEnumSavePoint");
1266 }
1267
1268 //[Test]
1269 //public void TestLookupEnumSavePoint()
1270 //{
1271 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSavePoint");
1272
1273 // Assert.AreEqual("Lookup NoPointFile from ESavePoint", GAMSOptions.ESavePoint.NoPointFile, GAMSOptions.ESavePoint.lookup(0));
1274 // Assert.AreEqual("Lookup LastSolvePointFile from ESavePoint", GAMSOptions.ESavePoint.LastSolvePointFile, GAMSOptions.ESavePoint.lookup(1));
1275 // Assert.AreEqual("Lookup EverySolvePointFile from ESavePoint", GAMSOptions.ESavePoint.EverySolvePointFile, GAMSOptions.ESavePoint.lookup(2));
1276 // Assert.AreEqual("Lookup LastSolvePointFileScrDir from ESavePoint", GAMSOptions.ESavePoint.LastSolvePointFileScrDir, GAMSOptions.ESavePoint.lookup(3));
1277 // Assert.AreEqual("Lookup EverySolvePointFileScrDir from ESavePoint", GAMSOptions.ESavePoint.EverySolvePointFileScrDir, GAMSOptions.ESavePoint.lookup(4));
1278
1279 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSavePoint");
1280 //}
1281
1282
1283 [Test]
1284 public void TestEnumShowOSMemory()
1285 {
1286 logger.Debug("Entering TestGAMSOptions | testEnumShowOSMemory");
1287
1288 globalOpt.ShowOSMemory = (GAMSOptions.EShowOSMemory.InternalAccounting);
1289 Assert.AreEqual(GAMSOptions.EShowOSMemory.InternalAccounting, globalOpt.ShowOSMemory, "expect same options " + GAMSOptions.EShowOSMemory.InternalAccounting + " set");
1290
1291 globalOpt.ShowOSMemory = (GAMSOptions.EShowOSMemory.RSS);
1292 Assert.AreEqual(GAMSOptions.EShowOSMemory.RSS, globalOpt.ShowOSMemory, "expect same options " + GAMSOptions.EShowOSMemory.RSS + " set");
1293
1294 globalOpt.ShowOSMemory = (GAMSOptions.EShowOSMemory.VSS);
1295 Assert.AreEqual(GAMSOptions.EShowOSMemory.VSS, globalOpt.ShowOSMemory, "expect same options " + GAMSOptions.EShowOSMemory.VSS + " set");
1296
1297 logger.Debug("Exiting TestGAMSOptions | testEnumShowOSMemory");
1298 }
1299
1300 //[Test]
1301 //public void TestLookupEnumShowOSMemory()
1302 //{
1303 // logger.Debug("Entering TestGAMSOptions | testLookupEnumShowOSMemory");
1304
1305 // Assert.AreEqual("Lookup InternalAccounting from EShowOSMemory", GAMSOptions.EShowOSMemory.InternalAccounting, GAMSOptions.EShowOSMemory.lookup(0));
1306 // Assert.AreEqual("Lookup RSS from EShowOSMemory", GAMSOptions.EShowOSMemory.RSS, GAMSOptions.EShowOSMemory.lookup(1));
1307 // Assert.AreEqual("Lookup VSS from EShowOSMemory", GAMSOptions.EShowOSMemory.VSS, GAMSOptions.EShowOSMemory.lookup(2));
1308
1309 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumShowOSMemory");
1310 //}
1311
1312
1313 [Test]
1314 public void TestEnumSolPrint()
1315 {
1316 logger.Debug("Entering TestGAMSOptions | testEnumSolPrint");
1317
1318 globalOpt.SolPrint = (GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves);
1319 Assert.AreEqual(GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves, globalOpt.SolPrint, "expect same options " + GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves + " set");
1320
1321 globalOpt.SolPrint = (GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves);
1322 Assert.AreEqual(GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves, globalOpt.SolPrint, "expect same options " + GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves + " set");
1323
1324 globalOpt.SolPrint = (GAMSOptions.ESolPrint.SuppressAllSolInfo);
1325 Assert.AreEqual(GAMSOptions.ESolPrint.SuppressAllSolInfo, globalOpt.SolPrint, "expect same options " + GAMSOptions.ESolPrint.SuppressAllSolInfo + " set");
1326
1327 logger.Debug("Exiting TestGAMSOptions | testEnumSolPrint");
1328 }
1329
1330 //[Test]
1331 //public void TestLookupEnumSolPrint()
1332 //{
1333 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSolPrint");
1334
1335 // Assert.AreEqual("Lookup RemoveSolLstFollowingSolves from ESolPrint", GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves, GAMSOptions.ESolPrint.lookup(0));
1336 // Assert.AreEqual("Lookup IncludeSolLstFollowingSolves from ESolPrint", GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves, GAMSOptions.ESolPrint.lookup(1));
1337 // Assert.AreEqual("Lookup SuppressAllSolInfo from ESolPrint", GAMSOptions.ESolPrint.SuppressAllSolInfo, GAMSOptions.ESolPrint.lookup(2));
1338
1339 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSolPrint");
1340 //}
1341
1342
1343 [Test]
1344 public void TestEnumSolveLink()
1345 {
1346 logger.Debug("Entering TestGAMSOptions | testEnumSolveLink");
1347
1348 globalOpt.SolveLink = (GAMSOptions.ESolveLink.ChainScript);
1349 Assert.AreEqual(GAMSOptions.ESolveLink.ChainScript, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.ChainScript + " set");
1350
1351 globalOpt.SolveLink = (GAMSOptions.ESolveLink.CallScript);
1352 Assert.AreEqual(GAMSOptions.ESolveLink.CallScript, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.CallScript + " set");
1353
1354 globalOpt.SolveLink = (GAMSOptions.ESolveLink.CallModule);
1355 Assert.AreEqual(GAMSOptions.ESolveLink.CallModule, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.CallModule + " set");
1356
1357 globalOpt.SolveLink = (GAMSOptions.ESolveLink.AsyncGrid);
1358 Assert.AreEqual(GAMSOptions.ESolveLink.AsyncGrid, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.AsyncGrid + " set");
1359
1360 globalOpt.SolveLink = (GAMSOptions.ESolveLink.AsyncSimulate);
1361 Assert.AreEqual(GAMSOptions.ESolveLink.AsyncSimulate, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.AsyncSimulate + " set");
1362
1363 globalOpt.SolveLink = (GAMSOptions.ESolveLink.LoadLibrary);
1364 Assert.AreEqual(GAMSOptions.ESolveLink.LoadLibrary, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.LoadLibrary + " set");
1365
1366 globalOpt.SolveLink = (GAMSOptions.ESolveLink.LoadLibraryAsync);
1367 Assert.AreEqual(GAMSOptions.ESolveLink.LoadLibraryAsync, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.LoadLibraryAsync + " set");
1368
1369 globalOpt.SolveLink = (GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate);
1370 Assert.AreEqual(GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate + " set");
1371
1372 logger.Debug("Exiting TestGAMSOptions | testEnumSolveLink");
1373 }
1374
1375 //[Test]
1376 //public void TestLookupEnumSolveLink()
1377 //{
1378 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSolveLink");
1379
1380 // Assert.AreEqual("Lookup ChainScript from ESolveLink", GAMSOptions.ESolveLink.ChainScript, GAMSOptions.ESolveLink.lookup(0));
1381 // Assert.AreEqual("Lookup CallScript from ESolveLink", GAMSOptions.ESolveLink.CallScript, GAMSOptions.ESolveLink.lookup(1));
1382 // Assert.AreEqual("Lookup CallModule from ESolveLink", GAMSOptions.ESolveLink.CallModule, GAMSOptions.ESolveLink.lookup(2));
1383 // Assert.AreEqual("Lookup AsyncGrid from ESolveLink", GAMSOptions.ESolveLink.AsyncGrid, GAMSOptions.ESolveLink.lookup(3));
1384 // Assert.AreEqual("Lookup AsyncSimulate from ESolveLink", GAMSOptions.ESolveLink.AsyncSimulate, GAMSOptions.ESolveLink.lookup(4));
1385 // Assert.AreEqual("Lookup LoadLibrary from ESolveLink", GAMSOptions.ESolveLink.LoadLibrary, GAMSOptions.ESolveLink.lookup(5));
1386 // Assert.AreEqual("Lookup LoadLibraryAsync from ESolveLink", GAMSOptions.ESolveLink.LoadLibraryAsync, GAMSOptions.ESolveLink.lookup(6));
1387 // Assert.AreEqual("Lookup LoadLibraryAsyncSimulate from ESolveLink", GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate, GAMSOptions.ESolveLink.lookup(7));
1388
1389 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSolveLink");
1390 //}
1391
1392
1393 [Test]
1394 public void TestEnumStepSum()
1395 {
1396 logger.Debug("Entering TestGAMSOptions | testEnumStepSum");
1397
1398 globalOpt.StepSum = (GAMSOptions.EStepSum.NoStepSummmary);
1399 Assert.AreEqual(GAMSOptions.EStepSum.NoStepSummmary, globalOpt.StepSum, "expect same options " + GAMSOptions.EStepSum.NoStepSummmary + " set");
1400
1401 globalOpt.StepSum = (GAMSOptions.EStepSum.StepSummary);
1402 Assert.AreEqual(GAMSOptions.EStepSum.StepSummary, globalOpt.StepSum, "expect same options " + GAMSOptions.EStepSum.StepSummary + " set");
1403
1404 logger.Debug("Exiting TestGAMSOptions | testEnumStepSum");
1405 }
1406
1407 //[Test]
1408 //public void TestLookupEnumStepSum()
1409 //{
1410 // logger.Debug("Entering TestGAMSOptions | testLookupEnumStepSum");
1411
1412 // Assert.AreEqual("Lookup NoStepSummmary from EStepSum", GAMSOptions.EStepSum.NoStepSummmary, GAMSOptions.EStepSum.lookup(0));
1413 // Assert.AreEqual("Lookup StepSummary from EStepSum", GAMSOptions.EStepSum.StepSummary, GAMSOptions.EStepSum.lookup(1));
1414
1415 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumStepSum");
1416 //}
1417
1418
1419 [Test]
1420 public void TestEnumstrictSingleton()
1421 {
1422 logger.Debug("Entering TestGAMSOptions | testEnumstrictSingleton");
1423
1424 globalOpt.strictSingleton = (GAMSOptions.EstrictSingleton.FirstRecord);
1425 Assert.AreEqual(GAMSOptions.EstrictSingleton.FirstRecord, globalOpt.strictSingleton, "expect same options " + GAMSOptions.EstrictSingleton.FirstRecord + " set");
1426
1427 globalOpt.strictSingleton = (GAMSOptions.EstrictSingleton.Error);
1428 Assert.AreEqual(GAMSOptions.EstrictSingleton.Error, globalOpt.strictSingleton, "expect same options " + GAMSOptions.EstrictSingleton.Error + " set");
1429
1430 logger.Debug("Exiting TestGAMSOptions | testEnumstrictSingleton");
1431 }
1432
1433 //[Test]
1434 //public void TestLookupEnumstrictSingleton()
1435 //{
1436 // logger.Debug("Entering TestGAMSOptions | testLookupEnumstrictSingleton");
1437
1438 // Assert.AreEqual("Lookup FirstRecord from EstrictSingleton", GAMSOptions.EstrictSingleton.FirstRecord, GAMSOptions.EstrictSingleton.lookup(0));
1439 // Assert.AreEqual("Lookup Error from EstrictSingleton", GAMSOptions.EstrictSingleton.Error, GAMSOptions.EstrictSingleton.lookup(1));
1440
1441 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumstrictSingleton");
1442 //}
1443
1444
1445 [Test]
1446 public void TestEnumStringChk()
1447 {
1448 logger.Debug("Entering TestGAMSOptions | testEnumStringChk");
1449
1450 globalOpt.StringChk = (GAMSOptions.EStringChk.NoError);
1451 Assert.AreEqual(GAMSOptions.EStringChk.NoError, globalOpt.StringChk, "expect same options " + GAMSOptions.EStringChk.NoError + " set");
1452
1453 globalOpt.StringChk = (GAMSOptions.EStringChk.Error);
1454 Assert.AreEqual(GAMSOptions.EStringChk.Error, globalOpt.StringChk, "expect same options " + GAMSOptions.EStringChk.Error + " set");
1455
1456 globalOpt.StringChk = (GAMSOptions.EStringChk.NoErrorRemoveSymbol);
1457 Assert.AreEqual(GAMSOptions.EStringChk.NoErrorRemoveSymbol, globalOpt.StringChk, "expect same options " + GAMSOptions.EStringChk.NoErrorRemoveSymbol + " set");
1458
1459 logger.Debug("Exiting TestGAMSOptions | testEnumStringChk");
1460 }
1461
1462 //[Test]
1463 //public void TestLookupEnumStringChk()
1464 //{
1465 // logger.Debug("Entering TestGAMSOptions | testLookupEnumStringChk");
1466
1467 // Assert.AreEqual("Lookup NoError from EStringChk", GAMSOptions.EStringChk.NoError, GAMSOptions.EStringChk.lookup(0));
1468 // Assert.AreEqual("Lookup Error from EStringChk", GAMSOptions.EStringChk.Error, GAMSOptions.EStringChk.lookup(1));
1469 // Assert.AreEqual("Lookup NoErrorRemoveSymbol from EStringChk", GAMSOptions.EStringChk.NoErrorRemoveSymbol, GAMSOptions.EStringChk.lookup(2));
1470
1471 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumStringChk");
1472 //}
1473
1474
1475 [Test]
1476 public void TestEnumSuffixDLVars()
1477 {
1478 logger.Debug("Entering TestGAMSOptions | testEnumSuffixDLVars");
1479
1480 globalOpt.SuffixDLVars = (GAMSOptions.ESuffixDLVars.OffSuffixDLVars);
1481 Assert.AreEqual(GAMSOptions.ESuffixDLVars.OffSuffixDLVars, globalOpt.SuffixDLVars, "expect same options " + GAMSOptions.ESuffixDLVars.OffSuffixDLVars + " set");
1482
1483 globalOpt.SuffixDLVars = (GAMSOptions.ESuffixDLVars.OnSuffixDLVars);
1484 Assert.AreEqual(GAMSOptions.ESuffixDLVars.OnSuffixDLVars, globalOpt.SuffixDLVars, "expect same options " + GAMSOptions.ESuffixDLVars.OnSuffixDLVars + " set");
1485
1486 logger.Debug("Exiting TestGAMSOptions | testEnumSuffixDLVars");
1487 }
1488
1489 //[Test]
1490 //public void TestLookupEnumSuffixDLVars()
1491 //{
1492 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSuffixDLVars");
1493
1494 // Assert.AreEqual("Lookup off from ESuffixDLVars", GAMSOptions.ESuffixDLVars.OffSuffixDLVars, GAMSOptions.ESuffixDLVars.lookup("off"));
1495 // Assert.AreEqual("Lookup on from ESuffixDLVars", GAMSOptions.ESuffixDLVars.OnSuffixDLVars, GAMSOptions.ESuffixDLVars.lookup("on"));
1496
1497 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSuffixDLVars");
1498 //}
1499
1500
1501 [Test]
1502 public void TestEnumSuffixAlgebraVars()
1503 {
1504 logger.Debug("Entering TestGAMSOptions | testEnumSuffixAlgebraVars");
1505
1506 globalOpt.SuffixAlgebraVars = (GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars);
1507 Assert.AreEqual(GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars, globalOpt.SuffixAlgebraVars, "expect same options " + GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars + " set");
1508
1509 globalOpt.SuffixAlgebraVars = (GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars);
1510 Assert.AreEqual(GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars, globalOpt.SuffixAlgebraVars, "expect same options " + GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars + " set");
1511
1512 logger.Debug("Exiting TestGAMSOptions | testEnumSuffixAlgebraVars");
1513 }
1514
1515 //[Test]
1516 //public void TestLookupEnumSuffixAlgebraVars()
1517 //{
1518 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSuffixAlgebraVars");
1519
1520 // Assert.AreEqual("Lookup off from ESuffixAlgebraVars", GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars, GAMSOptions.ESuffixAlgebraVars.lookup("off"));
1521 // Assert.AreEqual("Lookup on from ESuffixAlgebraVars", GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars, GAMSOptions.ESuffixAlgebraVars.lookup("on"));
1522
1523 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSuffixAlgebraVars");
1524 //}
1525
1526
1527 [Test]
1528 public void TestEnumSuppress()
1529 {
1530 logger.Debug("Entering TestGAMSOptions | testEnumSuppress");
1531
1532 globalOpt.Suppress = (GAMSOptions.ESuppress.StandardCompilerListing);
1533 Assert.AreEqual(GAMSOptions.ESuppress.StandardCompilerListing, globalOpt.Suppress, "expect same options " + GAMSOptions.ESuppress.StandardCompilerListing + " set");
1534
1535 globalOpt.Suppress = (GAMSOptions.ESuppress.SuppressCompilerListing);
1536 Assert.AreEqual(GAMSOptions.ESuppress.SuppressCompilerListing, globalOpt.Suppress, "expect same options " + GAMSOptions.ESuppress.SuppressCompilerListing + " set");
1537
1538 logger.Debug("Exiting TestGAMSOptions | testEnumSuppress");
1539 }
1540
1541 //[Test]
1542 //public void TestLookupEnumSuppress()
1543 //{
1544 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSuppress");
1545
1546 // Assert.AreEqual("Lookup StandardCompilerListing from ESuppress", GAMSOptions.ESuppress.StandardCompilerListing, GAMSOptions.ESuppress.lookup(0));
1547 // Assert.AreEqual("Lookup SuppressCompilerListing from ESuppress", GAMSOptions.ESuppress.SuppressCompilerListing, GAMSOptions.ESuppress.lookup(1));
1548
1549 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSuppress");
1550 //}
1551
1552
1553 [Test]
1554 public void TestEnumSys10()
1555 {
1556 logger.Debug("Entering TestGAMSOptions | testEnumSys10");
1557
1558 globalOpt.Sys10 = (GAMSOptions.ESys10.Disable);
1559 Assert.AreEqual(GAMSOptions.ESys10.Disable, globalOpt.Sys10, "expect same options " + GAMSOptions.ESys10.Disable + " set");
1560
1561 globalOpt.Sys10 = (GAMSOptions.ESys10.Enable);
1562 Assert.AreEqual(GAMSOptions.ESys10.Enable, globalOpt.Sys10, "expect same options " + GAMSOptions.ESys10.Enable + " set");
1563
1564 logger.Debug("Exiting TestGAMSOptions | testEnumSys10");
1565 }
1566
1567 //[Test]
1568 //public void TestLookupEnumSys10()
1569 //{
1570 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSys10");
1571
1572 // Assert.AreEqual("Lookup Disable from ESys10", GAMSOptions.ESys10.Disable, GAMSOptions.ESys10.lookup(0));
1573 // Assert.AreEqual("Lookup Enable from ESys10", GAMSOptions.ESys10.Enable, GAMSOptions.ESys10.lookup(1));
1574
1575 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSys10");
1576 //}
1577
1578
1579 [Test]
1580 public void TestEnumSys11()
1581 {
1582 logger.Debug("Entering TestGAMSOptions | testEnumSys11");
1583
1584 globalOpt.Sys11 = (GAMSOptions.ESys11.AutomaticOptimization);
1585 Assert.AreEqual(GAMSOptions.ESys11.AutomaticOptimization, globalOpt.Sys11, "expect same options " + GAMSOptions.ESys11.AutomaticOptimization + " set");
1586
1587 globalOpt.Sys11 = (GAMSOptions.ESys11.NoOptimization);
1588 Assert.AreEqual(GAMSOptions.ESys11.NoOptimization, globalOpt.Sys11, "expect same options " + GAMSOptions.ESys11.NoOptimization + " set");
1589
1590 globalOpt.Sys11 = (GAMSOptions.ESys11.AlwaysOptimize);
1591 Assert.AreEqual(GAMSOptions.ESys11.AlwaysOptimize, globalOpt.Sys11, "expect same options " + GAMSOptions.ESys11.AlwaysOptimize + " set");
1592
1593 logger.Debug("Exiting TestGAMSOptions | testEnumSys11");
1594 }
1595
1596 //[Test]
1597 //public void TestLookupEnumSys11()
1598 //{
1599 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSys11");
1600
1601 // Assert.AreEqual("Lookup AutomaticOptimization from ESys11", GAMSOptions.ESys11.AutomaticOptimization, GAMSOptions.ESys11.lookup(0));
1602 // Assert.AreEqual("Lookup NoOptimization from ESys11", GAMSOptions.ESys11.NoOptimization, GAMSOptions.ESys11.lookup(1));
1603 // Assert.AreEqual("Lookup AlwaysOptimize from ESys11", GAMSOptions.ESys11.AlwaysOptimize, GAMSOptions.ESys11.lookup(2));
1604
1605 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSys11");
1606 //}
1607
1608
1609 [Test]
1610 public void TestEnumSysOut()
1611 {
1612 logger.Debug("Entering TestGAMSOptions | testEnumSysOut");
1613
1614 globalOpt.SysOut = (GAMSOptions.ESysOut.SuppressAdditionalSolverOutput);
1615 Assert.AreEqual(GAMSOptions.ESysOut.SuppressAdditionalSolverOutput, globalOpt.SysOut, "expect same options " + GAMSOptions.ESysOut.SuppressAdditionalSolverOutput + " set");
1616
1617 globalOpt.SysOut = (GAMSOptions.ESysOut.IncludeAdditionalSolverOutput);
1618 Assert.AreEqual(GAMSOptions.ESysOut.IncludeAdditionalSolverOutput, globalOpt.SysOut, "expect same options " + GAMSOptions.ESysOut.IncludeAdditionalSolverOutput + " set");
1619
1620 logger.Debug("Exiting TestGAMSOptions | testEnumSysOut");
1621 }
1622
1623 //[Test]
1624 //public void TestLookupEnumSysOut()
1625 //{
1626 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSysOut");
1627
1628 // Assert.AreEqual("Lookup SuppressAdditionalSolverOutput from ESysOut", GAMSOptions.ESysOut.SuppressAdditionalSolverOutput, GAMSOptions.ESysOut.lookup(0));
1629 // Assert.AreEqual("Lookup IncludeAdditionalSolverOutput from ESysOut", GAMSOptions.ESysOut.IncludeAdditionalSolverOutput, GAMSOptions.ESysOut.lookup(1));
1630
1631 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSysOut");
1632 //}
1633
1634
1635 [Test]
1636 public void TestEnumTFormat()
1637 {
1638 logger.Debug("Entering TestGAMSOptions | testEnumTFormat");
1639
1640 globalOpt.TFormat = (GAMSOptions.ETFormat.Colon);
1641 Assert.AreEqual(GAMSOptions.ETFormat.Colon, globalOpt.TFormat, "expect same options " + GAMSOptions.ETFormat.Colon + " set");
1642
1643 globalOpt.TFormat = (GAMSOptions.ETFormat.Dot);
1644 Assert.AreEqual(GAMSOptions.ETFormat.Dot, globalOpt.TFormat, "expect same options " + GAMSOptions.ETFormat.Dot + " set");
1645
1646 logger.Debug("Exiting TestGAMSOptions | testEnumTFormat");
1647 }
1648
1649 //[Test]
1650 //public void TestLookupEnumTFormat()
1651 //{
1652 // logger.Debug("Entering TestGAMSOptions | testLookupEnumTFormat");
1653
1654 // Assert.AreEqual("Lookup Colon from ETFormat", GAMSOptions.ETFormat.Colon, GAMSOptions.ETFormat.lookup(0));
1655 // Assert.AreEqual("Lookup Dot from ETFormat", GAMSOptions.ETFormat.Dot, GAMSOptions.ETFormat.lookup(1));
1656
1657 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumTFormat");
1658 //}
1659
1660
1661 [Test]
1662 public void TestEnumTraceOpt()
1663 {
1664 logger.Debug("Entering TestGAMSOptions | testEnumTraceOpt");
1665
1666 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders);
1667 Assert.AreEqual(GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders + " set");
1668
1669 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace);
1670 Assert.AreEqual(GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace + " set");
1671
1672 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.SolverStepTraceOnly);
1673 Assert.AreEqual(GAMSOptions.ETraceOpt.SolverStepTraceOnly, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.SolverStepTraceOnly + " set");
1674
1675 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld);
1676 Assert.AreEqual(GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld + " set");
1677
1678 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC);
1679 Assert.AreEqual(GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC + " set");
1680
1681 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields);
1682 Assert.AreEqual(GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields + " set");
1683
1684 logger.Debug("Exiting TestGAMSOptions | testEnumTraceOpt");
1685 }
1686
1687 //[Test]
1688 //public void TestLookupEnumTraceOpt()
1689 //{
1690 // logger.Debug("Entering TestGAMSOptions | testLookupEnumTraceOpt");
1691
1692 // Assert.AreEqual("Lookup SolverAndGAMSStepTraceWOHeaders from ETraceOpt", GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders, GAMSOptions.ETraceOpt.lookup(0));
1693 // Assert.AreEqual("Lookup SolverAndGAMSStepTrace from ETraceOpt", GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace, GAMSOptions.ETraceOpt.lookup(1));
1694 // Assert.AreEqual("Lookup SolverStepTraceOnly from ETraceOpt", GAMSOptions.ETraceOpt.SolverStepTraceOnly, GAMSOptions.ETraceOpt.lookup(2));
1695 // Assert.AreEqual("Lookup TraceFileFormatGAMSPerformanceWorld from ETraceOpt", GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld, GAMSOptions.ETraceOpt.lookup(3));
1696 // Assert.AreEqual("Lookup TraceFileFormatSupportingNLPEC from ETraceOpt", GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC, GAMSOptions.ETraceOpt.lookup(4));
1697 // Assert.AreEqual("Lookup TraceFileWithAllAvailableTraceFields from ETraceOpt", GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields, GAMSOptions.ETraceOpt.lookup(5));
1698
1699 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumTraceOpt");
1700 //}
1701
1702
1703 [Test]
1704 public void TestEnumZeroResRep()
1705 {
1706 logger.Debug("Entering TestGAMSOptions | testEnumZeroResRep");
1707
1708 globalOpt.ZeroResRep = (GAMSOptions.EZeroResRep.NoWarning);
1709 Assert.AreEqual(GAMSOptions.EZeroResRep.NoWarning, globalOpt.ZeroResRep, "expect same options " + GAMSOptions.EZeroResRep.NoWarning + " set");
1710
1711 globalOpt.ZeroResRep = (GAMSOptions.EZeroResRep.IssueWarning);
1712 Assert.AreEqual(GAMSOptions.EZeroResRep.IssueWarning, globalOpt.ZeroResRep, "expect same options " + GAMSOptions.EZeroResRep.IssueWarning + " set");
1713
1714 logger.Debug("Exiting TestGAMSOptions | testEnumZeroResRep");
1715 }
1716
1717 //[Test]
1718 //public void TestLookupEnumZeroResRep()
1719 //{
1720 // logger.Debug("Entering TestGAMSOptions | testLookupEnumZeroResRep");
1721
1722 // Assert.AreEqual("Lookup NoWarning from EZeroResRep", GAMSOptions.EZeroResRep.NoWarning, GAMSOptions.EZeroResRep.lookup(0));
1723 // Assert.AreEqual("Lookup IssueWarning from EZeroResRep", GAMSOptions.EZeroResRep.IssueWarning, GAMSOptions.EZeroResRep.lookup(1));
1724
1725 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumZeroResRep");
1726 //}
1727
1728
1729
1730 }
1731}
GAMS::GAMSOptions::gdxConvert
EgdxConvert gdxConvert
GAMS::GAMSOptions::IntVarUp
EIntVarUp IntVarUp
GAMS::GAMSOptions::TraceOpt
ETraceOpt TraceOpt
GAMS::GAMSOptions::FreeEmbeddedPython
EFreeEmbeddedPython FreeEmbeddedPython
GAMS::GAMSOptions::PrefixLoadPath
EPrefixLoadPath PrefixLoadPath
GAMS::GAMSOptions::AppendOut
EAppendOut AppendOut
GAMS::GAMSOptions::ECImplicitLoad
EECImplicitLoad ECImplicitLoad
GAMS::GAMSOptions::HoldFixed
EHoldFixed HoldFixed
GAMS::GAMSOptions::StringChk
EStringChk StringChk
GAMS::GAMSOptions::ZeroResRep
EZeroResRep ZeroResRep
GAMS::GAMSOptions::NoNewVarEqu
ENoNewVarEqu NoNewVarEqu
GAMS::GAMSOptions::LstTitleLeftAligned
ELstTitleLeftAligned LstTitleLeftAligned
GAMS::GAMSOptions::Filtered
EFiltered Filtered
GAMS::GAMSOptions::SavePoint
ESavePoint SavePoint
GAMS::GAMSOptions::PreviousWork
EPreviousWork PreviousWork
GAMS::GAMSOptions::PageContr
EPageContr PageContr
GAMS::GAMSOptions::InteractiveSolver
EInteractiveSolver InteractiveSolver
GAMS::GAMSOptions::SolPrint
ESolPrint SolPrint
GAMS::GAMSOptions::ForceWork
EForceWork ForceWork
GAMS::GAMSOptions::SuffixDLVars
ESuffixDLVars SuffixDLVars
GAMS::GAMSOptions::ReferenceLineNo
EReferenceLineNo ReferenceLineNo
GAMS::GAMSOptions::Suppress
ESuppress Suppress
GAMS::GAMSOptions::gdxCompress
EgdxCompress gdxCompress
GAMS::GAMSOptions::FileCase
EFileCase FileCase
GAMS::GAMSOptions::strictSingleton
EstrictSingleton strictSingleton
GAMS::GAMSOptions::ProcTreeMemMonitor
EProcTreeMemMonitor ProcTreeMemMonitor
GAMS::GAMSOptions::ExecMode
EExecMode ExecMode
GAMS::GAMSOptions::AsyncSolLst
EAsyncSolLst AsyncSolLst
GAMS::GAMSOptions::SuffixAlgebraVars
ESuffixAlgebraVars SuffixAlgebraVars
GAMS::GAMSOptions::ShowOSMemory
EShowOSMemory ShowOSMemory
GAMS::GAMSOptions::AppendExpand
EAppendExpand AppendExpand
GAMS::GAMSOptions::CheckErrorLevel
ECheckErrorLevel CheckErrorLevel
GAMS::GAMSOptions::SolveLink
ESolveLink SolveLink
GAMS::GAMSOptions::DumpParms
EDumpParms DumpParms
GAMS::GAMSOptions::CaptureModelInstance
ECaptureModelInstance CaptureModelInstance
GAMS::GAMSOptions::HoldFixedAsync
EHoldFixedAsync HoldFixedAsync
GAMS::GAMSWorkspace::AddOptions
GAMSOptions AddOptions(GAMSOptions optFrom=null)
GamsApiTests.HouseKeeper.initializeTestFrom
static void initializeTestFrom(String filename, String subdir)
initialize class properties from fileName and prepare directory subdir
Definition: HouseKeeper.cs:114